| /* |
| * Copyright (c) 1997, 2010, 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.util.Arrays; |
| |
| /** |
| * This class represents pixel data packed such that the N samples which make |
| * up a single pixel are stored in a single data array element, and each data |
| * data array element holds samples for only one pixel. |
| * This class supports |
| * {@link DataBuffer#TYPE_BYTE TYPE_BYTE}, |
| * {@link DataBuffer#TYPE_USHORT TYPE_USHORT}, |
| * {@link DataBuffer#TYPE_INT TYPE_INT} data types. |
| * All data array elements reside |
| * in the first bank of a DataBuffer. Accessor methods are provided so |
| * that the image data can be manipulated directly. Scanline stride is the |
| * number of data array elements between a given sample and the corresponding |
| * sample in the same column of the next scanline. Bit masks are the masks |
| * required to extract the samples representing the bands of the pixel. |
| * Bit offsets are the offsets in bits into the data array |
| * element of the samples representing the bands of the pixel. |
| * <p> |
| * The following code illustrates extracting the bits of the sample |
| * representing band <code>b</code> for pixel <code>x,y</code> |
| * from DataBuffer <code>data</code>: |
| * <pre> |
| * int sample = data.getElem(y * scanlineStride + x); |
| * sample = (sample & bitMasks[b]) >>> bitOffsets[b]; |
| * </pre> |
| */ |
| |
| public class SinglePixelPackedSampleModel extends SampleModel |
| { |
| /** Bit masks for all bands of the image data. */ |
| private int bitMasks[]; |
| |
| /** Bit Offsets for all bands of the image data. */ |
| private int bitOffsets[]; |
| |
| /** Bit sizes for all the bands of the image data. */ |
| private int bitSizes[]; |
| |
| /** Maximum bit size. */ |
| private int maxBitSize; |
| |
| /** Line stride of the region of image data described by this |
| * SinglePixelPackedSampleModel. |
| */ |
| private int scanlineStride; |
| |
| private static native void initIDs(); |
| static { |
| ColorModel.loadLibraries(); |
| initIDs(); |
| } |
| |
| /** |
| * Constructs a SinglePixelPackedSampleModel with bitMasks.length bands. |
| * Each sample is stored in a data array element in the position of |
| * its corresponding bit mask. Each bit mask must be contiguous and |
| * masks must not overlap. Bit masks exceeding data type capacity are |
| * truncated. |
| * @param dataType The data type for storing samples. |
| * @param w The width (in pixels) of the region of the |
| * image data described. |
| * @param h The height (in pixels) of the region of the |
| * image data described. |
| * @param bitMasks The bit masks for all bands. |
| * @throws IllegalArgumentException if <code>dataType</code> is not |
| * either <code>DataBuffer.TYPE_BYTE</code>, |
| * <code>DataBuffer.TYPE_USHORT</code>, or |
| * <code>DataBuffer.TYPE_INT</code> |
| */ |
| public SinglePixelPackedSampleModel(int dataType, int w, int h, |
| int bitMasks[]) { |
| this(dataType, w, h, w, bitMasks); |
| if (dataType != DataBuffer.TYPE_BYTE && |
| dataType != DataBuffer.TYPE_USHORT && |
| dataType != DataBuffer.TYPE_INT) { |
| throw new IllegalArgumentException("Unsupported data type "+ |
| dataType); |
| } |
| } |
| |
| /** |
| * Constructs a SinglePixelPackedSampleModel with bitMasks.length bands |
| * and a scanline stride equal to scanlineStride data array elements. |
| * Each sample is stored in a data array element in the position of |
| * its corresponding bit mask. Each bit mask must be contiguous and |
| * masks must not overlap. Bit masks exceeding data type capacity are |
| * truncated. |
| * @param dataType The data type for storing samples. |
| * @param w The width (in pixels) of the region of |
| * image data described. |
| * @param h The height (in pixels) of the region of |
| * image data described. |
| * @param scanlineStride The line stride of the image data. |
| * @param bitMasks The bit masks for all bands. |
| * @throws IllegalArgumentException if <code>w</code> or |
| * <code>h</code> is not greater than 0 |
| * @throws IllegalArgumentException if any mask in |
| * <code>bitMask</code> is not contiguous |
| * @throws IllegalArgumentException if <code>dataType</code> is not |
| * either <code>DataBuffer.TYPE_BYTE</code>, |
| * <code>DataBuffer.TYPE_USHORT</code>, or |
| * <code>DataBuffer.TYPE_INT</code> |
| */ |
| public SinglePixelPackedSampleModel(int dataType, int w, int h, |
| int scanlineStride, int bitMasks[]) { |
| super(dataType, w, h, bitMasks.length); |
| if (dataType != DataBuffer.TYPE_BYTE && |
| dataType != DataBuffer.TYPE_USHORT && |
| dataType != DataBuffer.TYPE_INT) { |
| throw new IllegalArgumentException("Unsupported data type "+ |
| dataType); |
| } |
| this.dataType = dataType; |
| this.bitMasks = (int[]) bitMasks.clone(); |
| this.scanlineStride = scanlineStride; |
| |
| this.bitOffsets = new int[numBands]; |
| this.bitSizes = new int[numBands]; |
| |
| int maxMask = (int)((1L << DataBuffer.getDataTypeSize(dataType)) - 1); |
| |
| this.maxBitSize = 0; |
| for (int i=0; i<numBands; i++) { |
| int bitOffset = 0, bitSize = 0, mask; |
| this.bitMasks[i] &= maxMask; |
| mask = this.bitMasks[i]; |
| if (mask != 0) { |
| while ((mask & 1) == 0) { |
| mask = mask >>> 1; |
| bitOffset++; |
| } |
| while ((mask & 1) == 1) { |
| mask = mask >>> 1; |
| bitSize++; |
| } |
| if (mask != 0) { |
| throw new IllegalArgumentException("Mask "+bitMasks[i]+ |
| " must be contiguous"); |
| } |
| } |
| bitOffsets[i] = bitOffset; |
| bitSizes[i] = bitSize; |
| if (bitSize > maxBitSize) { |
| maxBitSize = bitSize; |
| } |
| } |
| } |
| |
| /** |
| * Returns the number of data elements needed to transfer one pixel |
| * via the getDataElements and setDataElements methods. |
| * For a SinglePixelPackedSampleModel, this is one. |
| */ |
| public int getNumDataElements() { |
| return 1; |
| } |
| |
| /** |
| * Returns the size of the buffer (in data array elements) |
| * needed for a data buffer that matches this |
| * SinglePixelPackedSampleModel. |
| */ |
| private long getBufferSize() { |
| long size = scanlineStride * (height-1) + width; |
| return size; |
| } |
| |
| /** |
| * Creates a new SinglePixelPackedSampleModel with the specified |
| * width and height. The new SinglePixelPackedSampleModel will have the |
| * same storage data type and bit masks as this |
| * SinglePixelPackedSampleModel. |
| * @param w the width of the resulting <code>SampleModel</code> |
| * @param h the height of the resulting <code>SampleModel</code> |
| * @return a <code>SinglePixelPackedSampleModel</code> with the |
| * specified width and height. |
| * @throws IllegalArgumentException if <code>w</code> or |
| * <code>h</code> is not greater than 0 |
| */ |
| public SampleModel createCompatibleSampleModel(int w, int h) { |
| SampleModel sampleModel = new SinglePixelPackedSampleModel(dataType, w, h, |
| bitMasks); |
| return sampleModel; |
| } |
| |
| /** |
| * Creates a DataBuffer that corresponds to this |
| * SinglePixelPackedSampleModel. The DataBuffer's data type and size |
| * will be consistent with this SinglePixelPackedSampleModel. The |
| * DataBuffer will have a single bank. |
| */ |
| public DataBuffer createDataBuffer() { |
| DataBuffer dataBuffer = null; |
| |
| int size = (int)getBufferSize(); |
| switch (dataType) { |
| case DataBuffer.TYPE_BYTE: |
| dataBuffer = new DataBufferByte(size); |
| break; |
| case DataBuffer.TYPE_USHORT: |
| dataBuffer = new DataBufferUShort(size); |
| break; |
| case DataBuffer.TYPE_INT: |
| dataBuffer = new DataBufferInt(size); |
| break; |
| } |
| return dataBuffer; |
| } |
| |
| /** Returns the number of bits per sample for all bands. */ |
| public int[] getSampleSize() { |
| return bitSizes.clone(); |
| } |
| |
| /** Returns the number of bits per sample for the specified band. */ |
| public int getSampleSize(int band) { |
| return bitSizes[band]; |
| } |
| |
| /** Returns the offset (in data array elements) of pixel (x,y). |
| * The data element containing pixel <code>x,y</code> |
| * can be retrieved from a DataBuffer <code>data</code> with a |
| * SinglePixelPackedSampleModel <code>sppsm</code> as: |
| * <pre> |
| * data.getElem(sppsm.getOffset(x, y)); |
| * </pre> |
| * @param x the X coordinate of the specified pixel |
| * @param y the Y coordinate of the specified pixel |
| * @return the offset of the specified pixel. |
| */ |
| public int getOffset(int x, int y) { |
| int offset = y * scanlineStride + x; |
| return offset; |
| } |
| |
| /** Returns the bit offsets into the data array element representing |
| * a pixel for all bands. |
| * @return the bit offsets representing a pixel for all bands. |
| */ |
| public int [] getBitOffsets() { |
| return (int[])bitOffsets.clone(); |
| } |
| |
| /** Returns the bit masks for all bands. |
| * @return the bit masks for all bands. |
| */ |
| public int [] getBitMasks() { |
| return (int[])bitMasks.clone(); |
| } |
| |
| /** Returns the scanline stride of this SinglePixelPackedSampleModel. |
| * @return the scanline stride of this |
| * <code>SinglePixelPackedSampleModel</code>. |
| */ |
| public int getScanlineStride() { |
| return scanlineStride; |
| } |
| |
| /** |
| * This creates a new SinglePixelPackedSampleModel with a subset of the |
| * bands of this SinglePixelPackedSampleModel. The new |
| * SinglePixelPackedSampleModel can be used with any DataBuffer that the |
| * existing SinglePixelPackedSampleModel can be used with. The new |
| * SinglePixelPackedSampleModel/DataBuffer combination will represent |
| * an image with a subset of the bands of the original |
| * SinglePixelPackedSampleModel/DataBuffer combination. |
| * @exception RasterFormatException if the length of the bands argument is |
| * greater than the number of bands in |
| * the sample model. |
| */ |
| public SampleModel createSubsetSampleModel(int bands[]) { |
| if (bands.length > numBands) |
| throw new RasterFormatException("There are only " + |
| numBands + |
| " bands"); |
| int newBitMasks[] = new int[bands.length]; |
| for (int i=0; i<bands.length; i++) |
| newBitMasks[i] = bitMasks[bands[i]]; |
| |
| return new SinglePixelPackedSampleModel(this.dataType, width, height, |
| this.scanlineStride, newBitMasks); |
| } |
| |
| /** |
| * Returns data for a single pixel in a primitive array of type |
| * TransferType. For a SinglePixelPackedSampleModel, the array will |
| * have one element, and the type will be the same as the storage |
| * data type. Generally, obj |
| * should be passed in as null, so that the Object will be created |
| * automatically and will be of the right primitive data type. |
| * <p> |
| * The following code illustrates transferring data for one pixel from |
| * DataBuffer <code>db1</code>, whose storage layout is described by |
| * SinglePixelPackedSampleModel <code>sppsm1</code>, to |
| * DataBuffer <code>db2</code>, whose storage layout is described by |
| * SinglePixelPackedSampleModel <code>sppsm2</code>. |
| * The transfer will generally be more efficient than using |
| * getPixel/setPixel. |
| * <pre> |
| * SinglePixelPackedSampleModel sppsm1, sppsm2; |
| * DataBufferInt db1, db2; |
| * sppsm2.setDataElements(x, y, sppsm1.getDataElements(x, y, null, |
| * db1), db2); |
| * </pre> |
| * Using getDataElements/setDataElements to transfer between two |
| * DataBuffer/SampleModel pairs is legitimate if the SampleModels have |
| * the same number of bands, corresponding bands have the same number of |
| * bits per sample, and the TransferTypes are the same. |
| * <p> |
| * If obj is non-null, it should be a primitive array of type TransferType. |
| * Otherwise, a ClassCastException is thrown. An |
| * ArrayIndexOutOfBoundsException may be thrown if the coordinates are |
| * not in bounds, or if obj is non-null and is not large enough to hold |
| * the pixel data. |
| * @param x The X coordinate of the pixel location. |
| * @param y The Y coordinate of the pixel location. |
| * @param obj If non-null, a primitive array in which to return |
| * the pixel data. |
| * @param data The DataBuffer containing the image data. |
| * @return the data for the specified pixel. |
| * @see #setDataElements(int, int, Object, DataBuffer) |
| */ |
| public Object getDataElements(int x, int y, Object obj, DataBuffer data) { |
| // Bounds check for 'b' will be performed automatically |
| if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) { |
| throw new ArrayIndexOutOfBoundsException |
| ("Coordinate out of bounds!"); |
| } |
| |
| int type = getTransferType(); |
| |
| switch(type) { |
| |
| case DataBuffer.TYPE_BYTE: |
| |
| byte[] bdata; |
| |
| if (obj == null) |
| bdata = new byte[1]; |
| else |
| bdata = (byte[])obj; |
| |
| bdata[0] = (byte)data.getElem(y * scanlineStride + x); |
| |
| obj = (Object)bdata; |
| break; |
| |
| case DataBuffer.TYPE_USHORT: |
| |
| short[] sdata; |
| |
| if (obj == null) |
| sdata = new short[1]; |
| else |
| sdata = (short[])obj; |
| |
| sdata[0] = (short)data.getElem(y * scanlineStride + x); |
| |
| obj = (Object)sdata; |
| break; |
| |
| case DataBuffer.TYPE_INT: |
| |
| int[] idata; |
| |
| if (obj == null) |
| idata = new int[1]; |
| else |
| idata = (int[])obj; |
| |
| idata[0] = data.getElem(y * scanlineStride + x); |
| |
| obj = (Object)idata; |
| break; |
| } |
| |
| return obj; |
| } |
| |
| /** |
| * Returns all samples in for the specified pixel in an int array. |
| * ArrayIndexOutOfBoundsException may be thrown if the coordinates are |
| * not in bounds. |
| * @param x The X coordinate of the pixel location. |
| * @param y The Y coordinate of the pixel location. |
| * @param iArray If non-null, returns the samples in this array |
| * @param data The DataBuffer containing the image data. |
| * @return all samples for the specified pixel. |
| * @see #setPixel(int, int, int[], DataBuffer) |
| */ |
| public int [] getPixel(int x, int y, int iArray[], DataBuffer data) { |
| if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) { |
| throw new ArrayIndexOutOfBoundsException |
| ("Coordinate out of bounds!"); |
| } |
| int pixels[]; |
| if (iArray == null) { |
| pixels = new int [numBands]; |
| } else { |
| pixels = iArray; |
| } |
| |
| int value = data.getElem(y * scanlineStride + x); |
| for (int i=0; i<numBands; i++) { |
| pixels[i] = (value & bitMasks[i]) >>> bitOffsets[i]; |
| } |
| return pixels; |
| } |
| |
| /** |
| * Returns all samples for the specified rectangle of pixels in |
| * an int array, one sample per array element. |
| * ArrayIndexOutOfBoundsException may be thrown if the coordinates are |
| * not in bounds. |
| * @param x The X coordinate of the upper left pixel location. |
| * @param y The Y coordinate of the upper left pixel location. |
| * @param w The width of the pixel rectangle. |
| * @param h The height of the pixel rectangle. |
| * @param iArray If non-null, returns the samples in this array. |
| * @param data The DataBuffer containing the image data. |
| * @return all samples for the specified region of pixels. |
| * @see #setPixels(int, int, int, int, int[], DataBuffer) |
| */ |
| public int[] getPixels(int x, int y, int w, int h, |
| int iArray[], DataBuffer data) { |
| int x1 = x + w; |
| int y1 = y + h; |
| |
| if (x < 0 || x >= width || w > width || x1 < 0 || x1 > width || |
| y < 0 || y >= height || h > height || y1 < 0 || y1 > height) |
| { |
| throw new ArrayIndexOutOfBoundsException |
| ("Coordinate out of bounds!"); |
| } |
| int pixels[]; |
| if (iArray != null) { |
| pixels = iArray; |
| } else { |
| pixels = new int [w*h*numBands]; |
| } |
| int lineOffset = y*scanlineStride + x; |
| int dstOffset = 0; |
| |
| for (int i = 0; i < h; i++) { |
| for (int j = 0; j < w; j++) { |
| int value = data.getElem(lineOffset+j); |
| for (int k=0; k < numBands; k++) { |
| pixels[dstOffset++] = |
| ((value & bitMasks[k]) >>> bitOffsets[k]); |
| } |
| } |
| lineOffset += scanlineStride; |
| } |
| return pixels; |
| } |
| |
| /** |
| * Returns as int the sample in a specified band for the pixel |
| * located at (x,y). |
| * ArrayIndexOutOfBoundsException may be thrown if the coordinates are |
| * not in bounds. |
| * @param x The X coordinate of the pixel location. |
| * @param y The Y coordinate of the pixel location. |
| * @param b The band to return. |
| * @param data The DataBuffer containing the image data. |
| * @return the sample in a specified band for the specified |
| * pixel. |
| * @see #setSample(int, int, int, int, DataBuffer) |
| */ |
| public int getSample(int x, int y, int b, DataBuffer data) { |
| // Bounds check for 'b' will be performed automatically |
| if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) { |
| throw new ArrayIndexOutOfBoundsException |
| ("Coordinate out of bounds!"); |
| } |
| int sample = data.getElem(y * scanlineStride + x); |
| return ((sample & bitMasks[b]) >>> bitOffsets[b]); |
| } |
| |
| /** |
| * Returns the samples for a specified band for the specified rectangle |
| * of pixels in an int array, one sample per array element. |
| * ArrayIndexOutOfBoundsException may be thrown if the coordinates are |
| * not in bounds. |
| * @param x The X coordinate of the upper left pixel location. |
| * @param y The Y coordinate of the upper left pixel location. |
| * @param w The width of the pixel rectangle. |
| * @param h The height of the pixel rectangle. |
| * @param b The band to return. |
| * @param iArray If non-null, returns the samples in this array. |
| * @param data The DataBuffer containing the image data. |
| * @return the samples for the specified band for the specified |
| * region of pixels. |
| * @see #setSamples(int, int, int, int, int, int[], DataBuffer) |
| */ |
| public int[] getSamples(int x, int y, int w, int h, int b, |
| int iArray[], DataBuffer data) { |
| // Bounds check for 'b' will be performed automatically |
| if ((x < 0) || (y < 0) || (x + w > width) || (y + h > height)) { |
| throw new ArrayIndexOutOfBoundsException |
| ("Coordinate out of bounds!"); |
| } |
| int samples[]; |
| if (iArray != null) { |
| samples = iArray; |
| } else { |
| samples = new int [w*h]; |
| } |
| int lineOffset = y*scanlineStride + x; |
| int dstOffset = 0; |
| |
| for (int i = 0; i < h; i++) { |
| for (int j = 0; j < w; j++) { |
| int value = data.getElem(lineOffset+j); |
| samples[dstOffset++] = |
| ((value & bitMasks[b]) >>> bitOffsets[b]); |
| } |
| lineOffset += scanlineStride; |
| } |
| return samples; |
| } |
| |
| /** |
| * Sets the data for a single pixel in the specified DataBuffer from a |
| * primitive array of type TransferType. For a |
| * SinglePixelPackedSampleModel, only the first element of the array |
| * will hold valid data, and the type of the array must be the same as |
| * the storage data type of the SinglePixelPackedSampleModel. |
| * <p> |
| * The following code illustrates transferring data for one pixel from |
| * DataBuffer <code>db1</code>, whose storage layout is described by |
| * SinglePixelPackedSampleModel <code>sppsm1</code>, |
| * to DataBuffer <code>db2</code>, whose storage layout is described by |
| * SinglePixelPackedSampleModel <code>sppsm2</code>. |
| * The transfer will generally be more efficient than using |
| * getPixel/setPixel. |
| * <pre> |
| * SinglePixelPackedSampleModel sppsm1, sppsm2; |
| * DataBufferInt db1, db2; |
| * sppsm2.setDataElements(x, y, sppsm1.getDataElements(x, y, null, |
| * db1), db2); |
| * </pre> |
| * Using getDataElements/setDataElements to transfer between two |
| * DataBuffer/SampleModel pairs is legitimate if the SampleModels have |
| * the same number of bands, corresponding bands have the same number of |
| * bits per sample, and the TransferTypes are the same. |
| * <p> |
| * obj must be a primitive array of type TransferType. Otherwise, |
| * a ClassCastException is thrown. An |
| * ArrayIndexOutOfBoundsException may be thrown if the coordinates are |
| * not in bounds, or if obj is not large enough to hold the pixel data. |
| * @param x The X coordinate of the pixel location. |
| * @param y The Y coordinate of the pixel location. |
| * @param obj A primitive array containing pixel data. |
| * @param data The DataBuffer containing the image data. |
| * @see #getDataElements(int, int, Object, DataBuffer) |
| */ |
| public void setDataElements(int x, int y, Object obj, DataBuffer data) { |
| if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) { |
| throw new ArrayIndexOutOfBoundsException |
| ("Coordinate out of bounds!"); |
| } |
| |
| int type = getTransferType(); |
| |
| switch(type) { |
| |
| case DataBuffer.TYPE_BYTE: |
| |
| byte[] barray = (byte[])obj; |
| data.setElem(y*scanlineStride+x, ((int)barray[0])&0xff); |
| break; |
| |
| case DataBuffer.TYPE_USHORT: |
| |
| short[] sarray = (short[])obj; |
| data.setElem(y*scanlineStride+x, ((int)sarray[0])&0xffff); |
| break; |
| |
| case DataBuffer.TYPE_INT: |
| |
| int[] iarray = (int[])obj; |
| data.setElem(y*scanlineStride+x, iarray[0]); |
| break; |
| } |
| } |
| |
| /** |
| * Sets a pixel in the DataBuffer using an int array of samples for input. |
| * ArrayIndexOutOfBoundsException may be thrown if the coordinates are |
| * not in bounds. |
| * @param x The X coordinate of the pixel location. |
| * @param y The Y coordinate of the pixel location. |
| * @param iArray The input samples in an int array. |
| * @param data The DataBuffer containing the image data. |
| * @see #getPixel(int, int, int[], DataBuffer) |
| */ |
| public void setPixel(int x, int y, |
| int iArray[], |
| DataBuffer data) { |
| if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) { |
| throw new ArrayIndexOutOfBoundsException |
| ("Coordinate out of bounds!"); |
| } |
| int lineOffset = y * scanlineStride + x; |
| int value = data.getElem(lineOffset); |
| for (int i=0; i < numBands; i++) { |
| value &= ~bitMasks[i]; |
| value |= ((iArray[i] << bitOffsets[i]) & bitMasks[i]); |
| } |
| data.setElem(lineOffset, value); |
| } |
| |
| /** |
| * Sets all samples for a rectangle of pixels from an int array containing |
| * one sample per array element. |
| * ArrayIndexOutOfBoundsException may be thrown if the coordinates are |
| * not in bounds. |
| * @param x The X coordinate of the upper left pixel location. |
| * @param y The Y coordinate of the upper left pixel location. |
| * @param w The width of the pixel rectangle. |
| * @param h The height of the pixel rectangle. |
| * @param iArray The input samples in an int array. |
| * @param data The DataBuffer containing the image data. |
| * @see #getPixels(int, int, int, int, int[], DataBuffer) |
| */ |
| public void setPixels(int x, int y, int w, int h, |
| int iArray[], DataBuffer data) { |
| int x1 = x + w; |
| int y1 = y + h; |
| |
| if (x < 0 || x >= width || w > width || x1 < 0 || x1 > width || |
| y < 0 || y >= height || h > height || y1 < 0 || y1 > height) |
| { |
| throw new ArrayIndexOutOfBoundsException |
| ("Coordinate out of bounds!"); |
| } |
| |
| int lineOffset = y*scanlineStride + x; |
| int srcOffset = 0; |
| |
| for (int i = 0; i < h; i++) { |
| for (int j = 0; j < w; j++) { |
| int value = data.getElem(lineOffset+j); |
| for (int k=0; k < numBands; k++) { |
| value &= ~bitMasks[k]; |
| int srcValue = iArray[srcOffset++]; |
| value |= ((srcValue << bitOffsets[k]) |
| & bitMasks[k]); |
| } |
| data.setElem(lineOffset+j, value); |
| } |
| lineOffset += scanlineStride; |
| } |
| } |
| |
| /** |
| * Sets a sample in the specified band for the pixel located at (x,y) |
| * in the DataBuffer using an int for input. |
| * ArrayIndexOutOfBoundsException may be thrown if the coordinates are |
| * not in bounds. |
| * @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 an int. |
| * @param data The DataBuffer containing the image data. |
| * @see #getSample(int, int, int, DataBuffer) |
| */ |
| public void setSample(int x, int y, int b, int s, |
| DataBuffer data) { |
| // Bounds check for 'b' will be performed automatically |
| if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) { |
| throw new ArrayIndexOutOfBoundsException |
| ("Coordinate out of bounds!"); |
| } |
| int value = data.getElem(y*scanlineStride + x); |
| value &= ~bitMasks[b]; |
| value |= (s << bitOffsets[b]) & bitMasks[b]; |
| data.setElem(y*scanlineStride + x,value); |
| } |
| |
| /** |
| * Sets the samples in the specified band for the specified rectangle |
| * of pixels from an int array containing one sample per array element. |
| * ArrayIndexOutOfBoundsException may be thrown if the coordinates are |
| * not in bounds. |
| * @param x The X coordinate of the upper left pixel location. |
| * @param y The Y coordinate of the upper left pixel location. |
| * @param w The width of the pixel rectangle. |
| * @param h The height of the pixel rectangle. |
| * @param b The band to set. |
| * @param iArray The input samples in an int array. |
| * @param data The DataBuffer containing the image data. |
| * @see #getSamples(int, int, int, int, int, int[], DataBuffer) |
| */ |
| public void setSamples(int x, int y, int w, int h, int b, |
| int iArray[], DataBuffer data) { |
| // Bounds check for 'b' will be performed automatically |
| if ((x < 0) || (y < 0) || (x + w > width) || (y + h > height)) { |
| throw new ArrayIndexOutOfBoundsException |
| ("Coordinate out of bounds!"); |
| } |
| int lineOffset = y*scanlineStride + x; |
| int srcOffset = 0; |
| |
| for (int i = 0; i < h; i++) { |
| for (int j = 0; j < w; j++) { |
| int value = data.getElem(lineOffset+j); |
| value &= ~bitMasks[b]; |
| int sample = iArray[srcOffset++]; |
| value |= ((int)sample << bitOffsets[b]) & bitMasks[b]; |
| data.setElem(lineOffset+j,value); |
| } |
| lineOffset += scanlineStride; |
| } |
| } |
| |
| public boolean equals(Object o) { |
| if ((o == null) || !(o instanceof SinglePixelPackedSampleModel)) { |
| return false; |
| } |
| |
| SinglePixelPackedSampleModel that = (SinglePixelPackedSampleModel)o; |
| return this.width == that.width && |
| this.height == that.height && |
| this.numBands == that.numBands && |
| this.dataType == that.dataType && |
| Arrays.equals(this.bitMasks, that.bitMasks) && |
| Arrays.equals(this.bitOffsets, that.bitOffsets) && |
| Arrays.equals(this.bitSizes, that.bitSizes) && |
| this.maxBitSize == that.maxBitSize && |
| this.scanlineStride == that.scanlineStride; |
| } |
| |
| // If we implement equals() we must also implement hashCode |
| public int hashCode() { |
| int hash = 0; |
| hash = width; |
| hash <<= 8; |
| hash ^= height; |
| hash <<= 8; |
| hash ^= numBands; |
| hash <<= 8; |
| hash ^= dataType; |
| hash <<= 8; |
| for (int i = 0; i < bitMasks.length; i++) { |
| hash ^= bitMasks[i]; |
| hash <<= 8; |
| } |
| for (int i = 0; i < bitOffsets.length; i++) { |
| hash ^= bitOffsets[i]; |
| hash <<= 8; |
| } |
| for (int i = 0; i < bitSizes.length; i++) { |
| hash ^= bitSizes[i]; |
| hash <<= 8; |
| } |
| hash ^= maxBitSize; |
| hash <<= 8; |
| hash ^= scanlineStride; |
| return hash; |
| } |
| } |
