Back to index...

	/*
	* Copyright (c) 2003, 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.
	*/

	package com.sun.imageio.plugins.common;

	import java.awt.Point;
	import java.awt.Rectangle;
	import java.awt.Transparency;
	import java.awt.color.ColorSpace;
	import java.awt.image.BufferedImage;
	import java.awt.image.ColorModel;
	import java.awt.image.ComponentColorModel;
	import java.awt.image.ComponentSampleModel;
	import java.awt.image.DataBuffer;
	import java.awt.image.DataBufferByte;
	import java.awt.image.DataBufferInt;
	import java.awt.image.DataBufferShort;
	import java.awt.image.DataBufferUShort;
	import java.awt.image.DirectColorModel;
	import java.awt.image.IndexColorModel;
	import java.awt.image.MultiPixelPackedSampleModel;
	import java.awt.image.Raster;
	import java.awt.image.RenderedImage;
	import java.awt.image.SampleModel;
	import java.awt.image.SinglePixelPackedSampleModel;
	import java.awt.image.WritableRaster;
	import java.util.Arrays;

	//import javax.imageio.ImageTypeSpecifier;

	import javax.imageio.IIOException;
	import javax.imageio.IIOImage;
	import javax.imageio.ImageTypeSpecifier;
	import javax.imageio.ImageWriter;
	import javax.imageio.spi.ImageWriterSpi;

	public class ImageUtil {
	/* XXX testing only
	public static void main(String[] args) {
	ImageTypeSpecifier bilevel =
	ImageTypeSpecifier.createIndexed(new byte[] {(byte)0, (byte)255},
	new byte[] {(byte)0, (byte)255},
	new byte[] {(byte)0, (byte)255},
	null, 1,
	DataBuffer.TYPE_BYTE);
	ImageTypeSpecifier gray =
	ImageTypeSpecifier.createGrayscale(8, DataBuffer.TYPE_BYTE, false);
	ImageTypeSpecifier grayAlpha =
	ImageTypeSpecifier.createGrayscale(8, DataBuffer.TYPE_BYTE, false,
	false);
	ImageTypeSpecifier rgb =
	ImageTypeSpecifier.createInterleaved(ColorSpace.getInstance(ColorSpace.CS_sRGB),
	new int[] {0, 1, 2},
	DataBuffer.TYPE_BYTE,
	false,
	false);
	ImageTypeSpecifier rgba =
	ImageTypeSpecifier.createInterleaved(ColorSpace.getInstance(ColorSpace.CS_sRGB),
	new int[] {0, 1, 2, 3},
	DataBuffer.TYPE_BYTE,
	true,
	false);
	ImageTypeSpecifier packed =
	ImageTypeSpecifier.createPacked(ColorSpace.getInstance(ColorSpace.CS_sRGB),
	0xff000000,
	0x00ff0000,
	0x0000ff00,
	0x000000ff,
	DataBuffer.TYPE_BYTE,
	false);

	SampleModel bandedSM =
	new java.awt.image.BandedSampleModel(DataBuffer.TYPE_BYTE,
	1, 1, 15);

	System.out.println(createColorModel(bilevel.getSampleModel()));
	System.out.println(createColorModel(gray.getSampleModel()));
	System.out.println(createColorModel(grayAlpha.getSampleModel()));
	System.out.println(createColorModel(rgb.getSampleModel()));
	System.out.println(createColorModel(rgba.getSampleModel()));
	System.out.println(createColorModel(packed.getSampleModel()));
	System.out.println(createColorModel(bandedSM));
	}
	*/

	/**
	* Creates a <code>ColorModel</code> that may be used with the
	* specified <code>SampleModel</code>. If a suitable
	* <code>ColorModel</code> cannot be found, this method returns
	* <code>null</code>.
	*
	* <p> Suitable <code>ColorModel</code>s are guaranteed to exist
	* for all instances of <code>ComponentSampleModel</code>.
	* For 1- and 3- banded <code>SampleModel</code>s, the returned
	* <code>ColorModel</code> will be opaque. For 2- and 4-banded
	* <code>SampleModel</code>s, the output will use alpha transparency
	* which is not premultiplied. 1- and 2-banded data will use a
	* grayscale <code>ColorSpace</code>, and 3- and 4-banded data a sRGB
	* <code>ColorSpace</code>. Data with 5 or more bands will have a
	* <code>BogusColorSpace</code>.</p>
	*
	* <p>An instance of <code>DirectColorModel</code> will be created for
	* instances of <code>SinglePixelPackedSampleModel</code> with no more
	* than 4 bands.</p>
	*
	* <p>An instance of <code>IndexColorModel</code> will be created for
	* instances of <code>MultiPixelPackedSampleModel</code>. The colormap
	* will be a grayscale ramp with <code>1 << numberOfBits</code>
	* entries ranging from zero to at most 255.</p>
	*
	* @return An instance of <code>ColorModel</code> that is suitable for
	* the supplied <code>SampleModel</code>, or <code>null</code>.
	*
	* @throws IllegalArgumentException If <code>sampleModel</code> is
	* <code>null</code>.
	*/
	public static final ColorModel createColorModel(SampleModel sampleModel) {
	// Check the parameter.
	if(sampleModel == null) {
	throw new IllegalArgumentException("sampleModel == null!");
	}

	// Get the data type.
	int dataType = sampleModel.getDataType();

	// Check the data type
	switch(dataType) {
	case DataBuffer.TYPE_BYTE:
	case DataBuffer.TYPE_USHORT:
	case DataBuffer.TYPE_SHORT:
	case DataBuffer.TYPE_INT:
	case DataBuffer.TYPE_FLOAT:
	case DataBuffer.TYPE_DOUBLE:
	break;
	default:
	// Return null for other types.
	return null;
	}

	// The return variable.
	ColorModel colorModel = null;

	// Get the sample size.
	int[] sampleSize = sampleModel.getSampleSize();

	// Create a Component ColorModel.
	if(sampleModel instanceof ComponentSampleModel) {
	// Get the number of bands.
	int numBands = sampleModel.getNumBands();

	// Determine the color space.
	ColorSpace colorSpace = null;
	if(numBands <= 2) {
	colorSpace = ColorSpace.getInstance(ColorSpace.CS_GRAY);
	} else if(numBands <= 4) {
	colorSpace = ColorSpace.getInstance(ColorSpace.CS_sRGB);
	} else {
	colorSpace = new BogusColorSpace(numBands);
	}

	boolean hasAlpha = (numBands == 2) \|\| (numBands == 4);
	boolean isAlphaPremultiplied = false;
	int transparency = hasAlpha ?
	Transparency.TRANSLUCENT : Transparency.OPAQUE;

	colorModel = new ComponentColorModel(colorSpace,
	sampleSize,
	hasAlpha,
	isAlphaPremultiplied,
	transparency,
	dataType);
	} else if (sampleModel.getNumBands() <= 4 &&
	sampleModel instanceof SinglePixelPackedSampleModel) {
	SinglePixelPackedSampleModel sppsm =
	(SinglePixelPackedSampleModel)sampleModel;

	int[] bitMasks = sppsm.getBitMasks();
	int rmask = 0;
	int gmask = 0;
	int bmask = 0;
	int amask = 0;

	int numBands = bitMasks.length;
	if (numBands <= 2) {
	rmask = gmask = bmask = bitMasks[0];
	if (numBands == 2) {
	amask = bitMasks[1];
	}
	} else {
	rmask = bitMasks[0];
	gmask = bitMasks[1];
	bmask = bitMasks[2];
	if (numBands == 4) {
	amask = bitMasks[3];
	}
	}

	int bits = 0;
	for (int i = 0; i < sampleSize.length; i++) {
	bits += sampleSize[i];
	}

	return new DirectColorModel(bits, rmask, gmask, bmask, amask);

	} else if(sampleModel instanceof MultiPixelPackedSampleModel) {
	// Load the colormap with a ramp.
	int bitsPerSample = sampleSize[0];
	int numEntries = 1 << bitsPerSample;
	byte[] map = new byte[numEntries];
	for (int i = 0; i < numEntries; i++) {
	map[i] = (byte)(i*255/(numEntries - 1));
	}

	colorModel = new IndexColorModel(bitsPerSample, numEntries,
	map, map, map);

	}

	return colorModel;
	}

	/**
	* For the case of binary data (<code>isBinary()</code> returns
	* <code>true</code>), return the binary data as a packed byte array.
	* The data will be packed as eight bits per byte with no bit offset,
	* i.e., the first bit in each image line will be the left-most of the
	* first byte of the line. The line stride in bytes will be
	* <code>(int)((getWidth()+7)/8)</code>. The length of the returned
	* array will be the line stride multiplied by <code>getHeight()</code>
	*
	* @return the binary data as a packed array of bytes with zero offset
	* of <code>null</code> if the data are not binary.
	* @throws IllegalArgumentException if <code>isBinary()</code> returns
	* <code>false</code> with the <code>SampleModel</code> of the
	* supplied <code>Raster</code> as argument.
	*/
	public static byte[] getPackedBinaryData(Raster raster,
	Rectangle rect) {
	SampleModel sm = raster.getSampleModel();
	if(!isBinary(sm)) {
	throw new IllegalArgumentException(I18N.getString("ImageUtil0"));
	}

	int rectX = rect.x;
	int rectY = rect.y;
	int rectWidth = rect.width;
	int rectHeight = rect.height;

	DataBuffer dataBuffer = raster.getDataBuffer();

	int dx = rectX - raster.getSampleModelTranslateX();
	int dy = rectY - raster.getSampleModelTranslateY();

	MultiPixelPackedSampleModel mpp = (MultiPixelPackedSampleModel)sm;
	int lineStride = mpp.getScanlineStride();
	int eltOffset = dataBuffer.getOffset() + mpp.getOffset(dx, dy);
	int bitOffset = mpp.getBitOffset(dx);

	int numBytesPerRow = (rectWidth + 7)/8;
	if(dataBuffer instanceof DataBufferByte &&
	eltOffset == 0 && bitOffset == 0 &&
	numBytesPerRow == lineStride &&
	((DataBufferByte)dataBuffer).getData().length ==
	numBytesPerRow*rectHeight) {
	return ((DataBufferByte)dataBuffer).getData();
	}

	byte[] binaryDataArray = new byte[numBytesPerRow*rectHeight];

	int b = 0;

	if(bitOffset == 0) {
	if(dataBuffer instanceof DataBufferByte) {
	byte[] data = ((DataBufferByte)dataBuffer).getData();
	int stride = numBytesPerRow;
	int offset = 0;
	for(int y = 0; y < rectHeight; y++) {
	System.arraycopy(data, eltOffset,
	binaryDataArray, offset,
	stride);
	offset += stride;
	eltOffset += lineStride;
	}
	} else if(dataBuffer instanceof DataBufferShort \|\|
	dataBuffer instanceof DataBufferUShort) {
	short[] data = dataBuffer instanceof DataBufferShort ?
	((DataBufferShort)dataBuffer).getData() :
	((DataBufferUShort)dataBuffer).getData();

	for(int y = 0; y < rectHeight; y++) {
	int xRemaining = rectWidth;
	int i = eltOffset;
	while(xRemaining > 8) {
	short datum = data[i++];
	binaryDataArray[b++] = (byte)((datum >>> 8) & 0xFF);
	binaryDataArray[b++] = (byte)(datum & 0xFF);
	xRemaining -= 16;
	}
	if(xRemaining > 0) {
	binaryDataArray[b++] = (byte)((data[i] >>> 8) & 0XFF);
	}
	eltOffset += lineStride;
	}
	} else if(dataBuffer instanceof DataBufferInt) {
	int[] data = ((DataBufferInt)dataBuffer).getData();

	for(int y = 0; y < rectHeight; y++) {
	int xRemaining = rectWidth;
	int i = eltOffset;
	while(xRemaining > 24) {
	int datum = data[i++];
	binaryDataArray[b++] = (byte)((datum >>> 24) & 0xFF);
	binaryDataArray[b++] = (byte)((datum >>> 16) & 0xFF);
	binaryDataArray[b++] = (byte)((datum >>> 8) & 0xFF);
	binaryDataArray[b++] = (byte)(datum & 0xFF);
	xRemaining -= 32;
	}
	int shift = 24;
	while(xRemaining > 0) {
	binaryDataArray[b++] =
	(byte)((data[i] >>> shift) & 0xFF);
	shift -= 8;
	xRemaining -= 8;
	}
	eltOffset += lineStride;
	}
	}
	} else { // bitOffset != 0
	if(dataBuffer instanceof DataBufferByte) {
	byte[] data = ((DataBufferByte)dataBuffer).getData();

	if((bitOffset & 7) == 0) {
	int stride = numBytesPerRow;
	int offset = 0;
	for(int y = 0; y < rectHeight; y++) {
	System.arraycopy(data, eltOffset,
	binaryDataArray, offset,
	stride);
	offset += stride;
	eltOffset += lineStride;
	}
	} else { // bitOffset % 8 != 0
	int leftShift = bitOffset & 7;
	int rightShift = 8 - leftShift;
	for(int y = 0; y < rectHeight; y++) {
	int i = eltOffset;
	int xRemaining = rectWidth;
	while(xRemaining > 0) {
	if(xRemaining > rightShift) {
	binaryDataArray[b++] =
	(byte)(((data[i++]&0xFF) << leftShift) \|
	((data[i]&0xFF) >>> rightShift));
	} else {
	binaryDataArray[b++] =
	(byte)((data[i]&0xFF) << leftShift);
	}
	xRemaining -= 8;
	}
	eltOffset += lineStride;
	}
	}
	} else if(dataBuffer instanceof DataBufferShort \|\|
	dataBuffer instanceof DataBufferUShort) {
	short[] data = dataBuffer instanceof DataBufferShort ?
	((DataBufferShort)dataBuffer).getData() :
	((DataBufferUShort)dataBuffer).getData();

	for(int y = 0; y < rectHeight; y++) {
	int bOffset = bitOffset;
	for(int x = 0; x < rectWidth; x += 8, bOffset += 8) {
	int i = eltOffset + bOffset/16;
	int mod = bOffset % 16;
	int left = data[i] & 0xFFFF;
	if(mod <= 8) {
	binaryDataArray[b++] = (byte)(left >>> (8 - mod));
	} else {
	int delta = mod - 8;
	int right = data[i+1] & 0xFFFF;
	binaryDataArray[b++] =
	(byte)((left << delta) \|
	(right >>> (16 - delta)));
	}
	}
	eltOffset += lineStride;
	}
	} else if(dataBuffer instanceof DataBufferInt) {
	int[] data = ((DataBufferInt)dataBuffer).getData();

	for(int y = 0; y < rectHeight; y++) {
	int bOffset = bitOffset;
	for(int x = 0; x < rectWidth; x += 8, bOffset += 8) {
	int i = eltOffset + bOffset/32;
	int mod = bOffset % 32;
	int left = data[i];
	if(mod <= 24) {
	binaryDataArray[b++] =
	(byte)(left >>> (24 - mod));
	} else {
	int delta = mod - 24;
	int right = data[i+1];
	binaryDataArray[b++] =
	(byte)((left << delta) \|
	(right >>> (32 - delta)));
	}
	}
	eltOffset += lineStride;
	}
	}
	}

	return binaryDataArray;
	}

	/**
	* Returns the binary data unpacked into an array of bytes.
	* The line stride will be the width of the <code>Raster</code>.
	*
	* @throws IllegalArgumentException if <code>isBinary()</code> returns
	* <code>false</code> with the <code>SampleModel</code> of the
	* supplied <code>Raster</code> as argument.
	*/
	public static byte[] getUnpackedBinaryData(Raster raster,
	Rectangle rect) {
	SampleModel sm = raster.getSampleModel();
	if(!isBinary(sm)) {
	throw new IllegalArgumentException(I18N.getString("ImageUtil0"));
	}

	int rectX = rect.x;
	int rectY = rect.y;
	int rectWidth = rect.width;
	int rectHeight = rect.height;

	DataBuffer dataBuffer = raster.getDataBuffer();

	int dx = rectX - raster.getSampleModelTranslateX();
	int dy = rectY - raster.getSampleModelTranslateY();

	MultiPixelPackedSampleModel mpp = (MultiPixelPackedSampleModel)sm;
	int lineStride = mpp.getScanlineStride();
	int eltOffset = dataBuffer.getOffset() + mpp.getOffset(dx, dy);
	int bitOffset = mpp.getBitOffset(dx);

	byte[] bdata = new byte[rectWidth*rectHeight];
	int maxY = rectY + rectHeight;
	int maxX = rectX + rectWidth;
	int k = 0;

	if(dataBuffer instanceof DataBufferByte) {
	byte[] data = ((DataBufferByte)dataBuffer).getData();
	for(int y = rectY; y < maxY; y++) {
	int bOffset = eltOffset*8 + bitOffset;
	for(int x = rectX; x < maxX; x++) {
	byte b = data[bOffset/8];
	bdata[k++] =
	(byte)((b >>> (7 - bOffset & 7)) & 0x0000001);
	bOffset++;
	}
	eltOffset += lineStride;
	}
	} else if(dataBuffer instanceof DataBufferShort \|\|
	dataBuffer instanceof DataBufferUShort) {
	short[] data = dataBuffer instanceof DataBufferShort ?
	((DataBufferShort)dataBuffer).getData() :
	((DataBufferUShort)dataBuffer).getData();
	for(int y = rectY; y < maxY; y++) {
	int bOffset = eltOffset*16 + bitOffset;
	for(int x = rectX; x < maxX; x++) {
	short s = data[bOffset/16];
	bdata[k++] =
	(byte)((s >>> (15 - bOffset % 16)) &
	0x0000001);
	bOffset++;
	}
	eltOffset += lineStride;
	}
	} else if(dataBuffer instanceof DataBufferInt) {
	int[] data = ((DataBufferInt)dataBuffer).getData();
	for(int y = rectY; y < maxY; y++) {
	int bOffset = eltOffset*32 + bitOffset;
	for(int x = rectX; x < maxX; x++) {
	int i = data[bOffset/32];
	bdata[k++] =
	(byte)((i >>> (31 - bOffset % 32)) &
	0x0000001);
	bOffset++;
	}
	eltOffset += lineStride;
	}
	}

	return bdata;
	}

	/**
	* Sets the supplied <code>Raster</code>'s data from an array
	* of packed binary data of the form returned by
	* <code>getPackedBinaryData()</code>.
	*
	* @throws IllegalArgumentException if <code>isBinary()</code> returns
	* <code>false</code> with the <code>SampleModel</code> of the
	* supplied <code>Raster</code> as argument.
	*/
	public static void setPackedBinaryData(byte[] binaryDataArray,
	WritableRaster raster,
	Rectangle rect) {
	SampleModel sm = raster.getSampleModel();
	if(!isBinary(sm)) {
	throw new IllegalArgumentException(I18N.getString("ImageUtil0"));
	}

	int rectX = rect.x;
	int rectY = rect.y;
	int rectWidth = rect.width;
	int rectHeight = rect.height;

	DataBuffer dataBuffer = raster.getDataBuffer();

	int dx = rectX - raster.getSampleModelTranslateX();
	int dy = rectY - raster.getSampleModelTranslateY();

	MultiPixelPackedSampleModel mpp = (MultiPixelPackedSampleModel)sm;
	int lineStride = mpp.getScanlineStride();
	int eltOffset = dataBuffer.getOffset() + mpp.getOffset(dx, dy);
	int bitOffset = mpp.getBitOffset(dx);

	int b = 0;

	if(bitOffset == 0) {
	if(dataBuffer instanceof DataBufferByte) {
	byte[] data = ((DataBufferByte)dataBuffer).getData();
	if(data == binaryDataArray) {
	// Optimal case: simply return.
	return;
	}
	int stride = (rectWidth + 7)/8;
	int offset = 0;
	for(int y = 0; y < rectHeight; y++) {
	System.arraycopy(binaryDataArray, offset,
	data, eltOffset,
	stride);
	offset += stride;
	eltOffset += lineStride;
	}
	} else if(dataBuffer instanceof DataBufferShort \|\|
	dataBuffer instanceof DataBufferUShort) {
	short[] data = dataBuffer instanceof DataBufferShort ?
	((DataBufferShort)dataBuffer).getData() :
	((DataBufferUShort)dataBuffer).getData();

	for(int y = 0; y < rectHeight; y++) {
	int xRemaining = rectWidth;
	int i = eltOffset;
	while(xRemaining > 8) {
	data[i++] =
	(short)(((binaryDataArray[b++] & 0xFF) << 8) \|
	(binaryDataArray[b++] & 0xFF));
	xRemaining -= 16;
	}
	if(xRemaining > 0) {
	data[i++] =
	(short)((binaryDataArray[b++] & 0xFF) << 8);
	}
	eltOffset += lineStride;
	}
	} else if(dataBuffer instanceof DataBufferInt) {
	int[] data = ((DataBufferInt)dataBuffer).getData();

	for(int y = 0; y < rectHeight; y++) {
	int xRemaining = rectWidth;
	int i = eltOffset;
	while(xRemaining > 24) {
	data[i++] =
	(int)(((binaryDataArray[b++] & 0xFF) << 24) \|
	((binaryDataArray[b++] & 0xFF) << 16) \|
	((binaryDataArray[b++] & 0xFF) << 8) \|
	(binaryDataArray[b++] & 0xFF));
	xRemaining -= 32;
	}
	int shift = 24;
	while(xRemaining > 0) {
	data[i] \|=
	(int)((binaryDataArray[b++] & 0xFF) << shift);
	shift -= 8;
	xRemaining -= 8;
	}
	eltOffset += lineStride;
	}
	}
	} else { // bitOffset != 0
	int stride = (rectWidth + 7)/8;
	int offset = 0;
	if(dataBuffer instanceof DataBufferByte) {
	byte[] data = ((DataBufferByte)dataBuffer).getData();

	if((bitOffset & 7) == 0) {
	for(int y = 0; y < rectHeight; y++) {
	System.arraycopy(binaryDataArray, offset,
	data, eltOffset,
	stride);
	offset += stride;
	eltOffset += lineStride;
	}
	} else { // bitOffset % 8 != 0
	int rightShift = bitOffset & 7;
	int leftShift = 8 - rightShift;
	int leftShift8 = 8 + leftShift;
	int mask = (byte)(255<<leftShift);
	int mask1 = (byte)~mask;

	for(int y = 0; y < rectHeight; y++) {
	int i = eltOffset;
	int xRemaining = rectWidth;
	while(xRemaining > 0) {
	byte datum = binaryDataArray[b++];

	if (xRemaining > leftShift8) {
	// when all the bits in this BYTE will be set
	// into the data buffer.
	data[i] = (byte)((data[i] & mask ) \|
	((datum&0xFF) >>> rightShift));
	data[++i] = (byte)((datum & 0xFF) << leftShift);
	} else if (xRemaining > leftShift) {
	// All the "leftShift" high bits will be set
	// into the data buffer. But not all the
	// "rightShift" low bits will be set.
	data[i] = (byte)((data[i] & mask ) \|
	((datum&0xFF) >>> rightShift));
	i++;
	data[i] =
	(byte)((data[i] & mask1) \| ((datum & 0xFF) << leftShift));
	}
	else {
	// Less than "leftShift" high bits will be set.
	int remainMask = (1 << leftShift - xRemaining) - 1;
	data[i] =
	(byte)((data[i] & (mask \| remainMask)) \|
	(datum&0xFF) >>> rightShift & ~remainMask);
	}
	xRemaining -= 8;
	}
	eltOffset += lineStride;
	}
	}
	} else if(dataBuffer instanceof DataBufferShort \|\|
	dataBuffer instanceof DataBufferUShort) {
	short[] data = dataBuffer instanceof DataBufferShort ?
	((DataBufferShort)dataBuffer).getData() :
	((DataBufferUShort)dataBuffer).getData();

	int rightShift = bitOffset & 7;
	int leftShift = 8 - rightShift;
	int leftShift16 = 16 + leftShift;
	int mask = (short)(~(255 << leftShift));
	int mask1 = (short)(65535 << leftShift);
	int mask2 = (short)~mask1;

	for(int y = 0; y < rectHeight; y++) {
	int bOffset = bitOffset;
	int xRemaining = rectWidth;
	for(int x = 0; x < rectWidth;
	x += 8, bOffset += 8, xRemaining -= 8) {
	int i = eltOffset + (bOffset >> 4);
	int mod = bOffset & 15;
	int datum = binaryDataArray[b++] & 0xFF;
	if(mod <= 8) {
	// This BYTE is set into one SHORT
	if (xRemaining < 8) {
	// Mask the bits to be set.
	datum &= 255 << 8 - xRemaining;
	}
	data[i] = (short)((data[i] & mask) \| (datum << leftShift));
	} else if (xRemaining > leftShift16) {
	// This BYTE will be set into two SHORTs
	data[i] = (short)((data[i] & mask1) \| ((datum >>> rightShift)&0xFFFF));
	data[++i] =
	(short)((datum << leftShift)&0xFFFF);
	} else if (xRemaining > leftShift) {
	// This BYTE will be set into two SHORTs;
	// But not all the low bits will be set into SHORT
	data[i] = (short)((data[i] & mask1) \| ((datum >>> rightShift)&0xFFFF));
	i++;
	data[i] =
	(short)((data[i] & mask2) \| ((datum << leftShift)&0xFFFF));
	} else {
	// Only some of the high bits will be set into
	// SHORTs
	int remainMask = (1 << leftShift - xRemaining) - 1;
	data[i] = (short)((data[i] & (mask1 \| remainMask)) \|
	((datum >>> rightShift)&0xFFFF & ~remainMask));
	}
	}
	eltOffset += lineStride;
	}
	} else if(dataBuffer instanceof DataBufferInt) {
	int[] data = ((DataBufferInt)dataBuffer).getData();
	int rightShift = bitOffset & 7;
	int leftShift = 8 - rightShift;
	int leftShift32 = 32 + leftShift;
	int mask = 0xFFFFFFFF << leftShift;
	int mask1 = ~mask;

	for(int y = 0; y < rectHeight; y++) {
	int bOffset = bitOffset;
	int xRemaining = rectWidth;
	for(int x = 0; x < rectWidth;
	x += 8, bOffset += 8, xRemaining -= 8) {
	int i = eltOffset + (bOffset >> 5);
	int mod = bOffset & 31;
	int datum = binaryDataArray[b++] & 0xFF;
	if(mod <= 24) {
	// This BYTE is set into one INT
	int shift = 24 - mod;
	if (xRemaining < 8) {
	// Mask the bits to be set.
	datum &= 255 << 8 - xRemaining;
	}
	data[i] = (data[i] & (~(255 << shift))) \| (datum << shift);
	} else if (xRemaining > leftShift32) {
	// All the bits of this BYTE will be set into two INTs
	data[i] = (data[i] & mask) \| (datum >>> rightShift);
	data[++i] = datum << leftShift;
	} else if (xRemaining > leftShift) {
	// This BYTE will be set into two INTs;
	// But not all the low bits will be set into INT
	data[i] = (data[i] & mask) \| (datum >>> rightShift);
	i++;
	data[i] = (data[i] & mask1) \| (datum << leftShift);
	} else {
	// Only some of the high bits will be set into INT
	int remainMask = (1 << leftShift - xRemaining) - 1;
	data[i] = (data[i] & (mask \| remainMask)) \|
	(datum >>> rightShift & ~remainMask);
	}
	}
	eltOffset += lineStride;
	}
	}
	}
	}

	/**
	* Copies data into the packed array of the <code>Raster</code>
	* from an array of unpacked data of the form returned by
	* <code>getUnpackedBinaryData()</code>.
	*
	* <p> If the data are binary, then the target bit will be set if
	* and only if the corresponding byte is non-zero.
	*
	* @throws IllegalArgumentException if <code>isBinary()</code> returns
	* <code>false</code> with the <code>SampleModel</code> of the
	* supplied <code>Raster</code> as argument.
	*/
	public static void setUnpackedBinaryData(byte[] bdata,
	WritableRaster raster,
	Rectangle rect) {
	SampleModel sm = raster.getSampleModel();
	if(!isBinary(sm)) {
	throw new IllegalArgumentException(I18N.getString("ImageUtil0"));
	}

	int rectX = rect.x;
	int rectY = rect.y;
	int rectWidth = rect.width;
	int rectHeight = rect.height;

	DataBuffer dataBuffer = raster.getDataBuffer();

	int dx = rectX - raster.getSampleModelTranslateX();
	int dy = rectY - raster.getSampleModelTranslateY();

	MultiPixelPackedSampleModel mpp = (MultiPixelPackedSampleModel)sm;
	int lineStride = mpp.getScanlineStride();
	int eltOffset = dataBuffer.getOffset() + mpp.getOffset(dx, dy);
	int bitOffset = mpp.getBitOffset(dx);

	int k = 0;

	if(dataBuffer instanceof DataBufferByte) {
	byte[] data = ((DataBufferByte)dataBuffer).getData();
	for(int y = 0; y < rectHeight; y++) {
	int bOffset = eltOffset*8 + bitOffset;
	for(int x = 0; x < rectWidth; x++) {
	if(bdata[k++] != (byte)0) {
	data[bOffset/8] \|=
	(byte)(0x00000001 << (7 - bOffset & 7));
	}
	bOffset++;
	}
	eltOffset += lineStride;
	}
	} else if(dataBuffer instanceof DataBufferShort \|\|
	dataBuffer instanceof DataBufferUShort) {
	short[] data = dataBuffer instanceof DataBufferShort ?
	((DataBufferShort)dataBuffer).getData() :
	((DataBufferUShort)dataBuffer).getData();
	for(int y = 0; y < rectHeight; y++) {
	int bOffset = eltOffset*16 + bitOffset;
	for(int x = 0; x < rectWidth; x++) {
	if(bdata[k++] != (byte)0) {
	data[bOffset/16] \|=
	(short)(0x00000001 <<
	(15 - bOffset % 16));
	}
	bOffset++;
	}
	eltOffset += lineStride;
	}
	} else if(dataBuffer instanceof DataBufferInt) {
	int[] data = ((DataBufferInt)dataBuffer).getData();
	for(int y = 0; y < rectHeight; y++) {
	int bOffset = eltOffset*32 + bitOffset;
	for(int x = 0; x < rectWidth; x++) {
	if(bdata[k++] != (byte)0) {
	data[bOffset/32] \|=
	(int)(0x00000001 <<
	(31 - bOffset % 32));
	}
	bOffset++;
	}
	eltOffset += lineStride;
	}
	}
	}

	public static boolean isBinary(SampleModel sm) {
	return sm instanceof MultiPixelPackedSampleModel &&
	((MultiPixelPackedSampleModel)sm).getPixelBitStride() == 1 &&
	sm.getNumBands() == 1;
	}

	public static ColorModel createColorModel(ColorSpace colorSpace,
	SampleModel sampleModel) {
	ColorModel colorModel = null;

	if(sampleModel == null) {
	throw new IllegalArgumentException(I18N.getString("ImageUtil1"));
	}

	int numBands = sampleModel.getNumBands();
	if (numBands < 1 \|\| numBands > 4) {
	return null;
	}

	int dataType = sampleModel.getDataType();
	if (sampleModel instanceof ComponentSampleModel) {
	if (dataType < DataBuffer.TYPE_BYTE \|\|
	//dataType == DataBuffer.TYPE_SHORT \|\|
	dataType > DataBuffer.TYPE_DOUBLE) {
	return null;
	}

	if (colorSpace == null)
	colorSpace =
	numBands <= 2 ?
	ColorSpace.getInstance(ColorSpace.CS_GRAY) :
	ColorSpace.getInstance(ColorSpace.CS_sRGB);

	boolean useAlpha = (numBands == 2) \|\| (numBands == 4);
	int transparency = useAlpha ?
	Transparency.TRANSLUCENT : Transparency.OPAQUE;

	boolean premultiplied = false;

	int dataTypeSize = DataBuffer.getDataTypeSize(dataType);
	int[] bits = new int[numBands];
	for (int i = 0; i < numBands; i++) {
	bits[i] = dataTypeSize;
	}

	colorModel = new ComponentColorModel(colorSpace,
	bits,
	useAlpha,
	premultiplied,
	transparency,
	dataType);
	} else if (sampleModel instanceof SinglePixelPackedSampleModel) {
	SinglePixelPackedSampleModel sppsm =
	(SinglePixelPackedSampleModel)sampleModel;

	int[] bitMasks = sppsm.getBitMasks();
	int rmask = 0;
	int gmask = 0;
	int bmask = 0;
	int amask = 0;

	numBands = bitMasks.length;
	if (numBands <= 2) {
	rmask = gmask = bmask = bitMasks[0];
	if (numBands == 2) {
	amask = bitMasks[1];
	}
	} else {
	rmask = bitMasks[0];
	gmask = bitMasks[1];
	bmask = bitMasks[2];
	if (numBands == 4) {
	amask = bitMasks[3];
	}
	}

	int[] sampleSize = sppsm.getSampleSize();
	int bits = 0;
	for (int i = 0; i < sampleSize.length; i++) {
	bits += sampleSize[i];
	}

	if (colorSpace == null)
	colorSpace = ColorSpace.getInstance(ColorSpace.CS_sRGB);

	colorModel =
	new DirectColorModel(colorSpace,
	bits, rmask, gmask, bmask, amask,
	false,
	sampleModel.getDataType());
	} else if (sampleModel instanceof MultiPixelPackedSampleModel) {
	int bits =
	((MultiPixelPackedSampleModel)sampleModel).getPixelBitStride();
	int size = 1 << bits;
	byte[] comp = new byte[size];

	for (int i = 0; i < size; i++)
	comp[i] = (byte)(255 * i / (size - 1));

	colorModel = new IndexColorModel(bits, size, comp, comp, comp);
	}

	return colorModel;
	}

	public static int getElementSize(SampleModel sm) {
	int elementSize = DataBuffer.getDataTypeSize(sm.getDataType());

	if (sm instanceof MultiPixelPackedSampleModel) {
	MultiPixelPackedSampleModel mppsm =
	(MultiPixelPackedSampleModel)sm;
	return mppsm.getSampleSize(0) * mppsm.getNumBands();
	} else if (sm instanceof ComponentSampleModel) {
	return sm.getNumBands() * elementSize;
	} else if (sm instanceof SinglePixelPackedSampleModel) {
	return elementSize;
	}

	return elementSize * sm.getNumBands();

	}

	public static long getTileSize(SampleModel sm) {
	int elementSize = DataBuffer.getDataTypeSize(sm.getDataType());

	if (sm instanceof MultiPixelPackedSampleModel) {
	MultiPixelPackedSampleModel mppsm =
	(MultiPixelPackedSampleModel)sm;
	return (mppsm.getScanlineStride() * mppsm.getHeight() +
	(mppsm.getDataBitOffset() + elementSize -1) / elementSize) *
	((elementSize + 7) / 8);
	} else if (sm instanceof ComponentSampleModel) {
	ComponentSampleModel csm = (ComponentSampleModel)sm;
	int[] bandOffsets = csm.getBandOffsets();
	int maxBandOff = bandOffsets[0];
	for (int i=1; i<bandOffsets.length; i++)
	maxBandOff = Math.max(maxBandOff, bandOffsets[i]);

	long size = 0;
	int pixelStride = csm.getPixelStride();
	int scanlineStride = csm.getScanlineStride();
	if (maxBandOff >= 0)
	size += maxBandOff + 1;
	if (pixelStride > 0)
	size += pixelStride * (sm.getWidth() - 1);
	if (scanlineStride > 0)
	size += scanlineStride * (sm.getHeight() - 1);

	int[] bankIndices = csm.getBankIndices();
	maxBandOff = bankIndices[0];
	for (int i=1; i<bankIndices.length; i++)
	maxBandOff = Math.max(maxBandOff, bankIndices[i]);
	return size * (maxBandOff + 1) * ((elementSize + 7) / 8);
	} else if (sm instanceof SinglePixelPackedSampleModel) {
	SinglePixelPackedSampleModel sppsm =
	(SinglePixelPackedSampleModel)sm;
	long size = sppsm.getScanlineStride() * (sppsm.getHeight() - 1) +
	sppsm.getWidth();
	return size * ((elementSize + 7) / 8);
	}

	return 0;
	}

	public static long getBandSize(SampleModel sm) {
	int elementSize = DataBuffer.getDataTypeSize(sm.getDataType());

	if (sm instanceof ComponentSampleModel) {
	ComponentSampleModel csm = (ComponentSampleModel)sm;
	int pixelStride = csm.getPixelStride();
	int scanlineStride = csm.getScanlineStride();
	long size = Math.min(pixelStride, scanlineStride);

	if (pixelStride > 0)
	size += pixelStride * (sm.getWidth() - 1);
	if (scanlineStride > 0)
	size += scanlineStride * (sm.getHeight() - 1);
	return size * ((elementSize + 7) / 8);
	} else
	return getTileSize(sm);
	}
	/**
	* Tests whether the color indices represent a gray-scale image.
	*
	* @param r The red channel color indices.
	* @param g The green channel color indices.
	* @param b The blue channel color indices.
	* @return If all the indices have 256 entries, and are identical mappings,
	* return <code>true</code>; otherwise, return <code>false</code>.
	*/
	public static boolean isIndicesForGrayscale(byte[] r, byte[] g, byte[] b) {
	if (r.length != g.length \|\| r.length != b.length)
	return false;

	int size = r.length;

	if (size != 256)
	return false;

	for (int i = 0; i < size; i++) {
	byte temp = (byte) i;

	if (r[i] != temp \|\| g[i] != temp \|\| b[i] != temp)
	return false;
	}

	return true;
	}

	/** Converts the provided object to <code>String</code> */
	public static String convertObjectToString(Object obj) {
	if (obj == null)
	return "";

	String s = "";
	if (obj instanceof byte[]) {
	byte[] bArray = (byte[])obj;
	for (int i = 0; i < bArray.length; i++)
	s += bArray[i] + " ";
	return s;
	}

	if (obj instanceof int[]) {
	int[] iArray = (int[])obj;
	for (int i = 0; i < iArray.length; i++)
	s += iArray[i] + " " ;
	return s;
	}

	if (obj instanceof short[]) {
	short[] sArray = (short[])obj;
	for (int i = 0; i < sArray.length; i++)
	s += sArray[i] + " " ;
	return s;
	}

	return obj.toString();

	}

	/** Checks that the provided <code>ImageWriter</code> can encode
	* the provided <code>ImageTypeSpecifier</code> or not. If not, an
	* <code>IIOException</code> will be thrown.
	* @param writer The provided <code>ImageWriter</code>.
	* @param type The image to be tested.
	* @throws IIOException If the writer cannot encoded the provided image.
	*/
	public static final void canEncodeImage(ImageWriter writer,
	ImageTypeSpecifier type)
	throws IIOException {
	ImageWriterSpi spi = writer.getOriginatingProvider();

	if(type != null && spi != null && !spi.canEncodeImage(type)) {
	throw new IIOException(I18N.getString("ImageUtil2")+" "+
	writer.getClass().getName());
	}
	}

	/** Checks that the provided <code>ImageWriter</code> can encode
	* the provided <code>ColorModel</code> and <code>SampleModel</code>.
	* If not, an <code>IIOException</code> will be thrown.
	* @param writer The provided <code>ImageWriter</code>.
	* @param colorModel The provided <code>ColorModel</code>.
	* @param sampleModel The provided <code>SampleModel</code>.
	* @throws IIOException If the writer cannot encoded the provided image.
	*/
	public static final void canEncodeImage(ImageWriter writer,
	ColorModel colorModel,
	SampleModel sampleModel)
	throws IIOException {
	ImageTypeSpecifier type = null;
	if (colorModel != null && sampleModel != null)
	type = new ImageTypeSpecifier(colorModel, sampleModel);
	canEncodeImage(writer, type);
	}

	/**
	* Returns whether the image has contiguous data across rows.
	*/
	public static final boolean imageIsContiguous(RenderedImage image) {
	SampleModel sm;
	if(image instanceof BufferedImage) {
	WritableRaster ras = ((BufferedImage)image).getRaster();
	sm = ras.getSampleModel();
	} else {
	sm = image.getSampleModel();
	}

	if (sm instanceof ComponentSampleModel) {
	// Ensure image rows samples are stored contiguously
	// in a single bank.
	ComponentSampleModel csm = (ComponentSampleModel)sm;

	if (csm.getPixelStride() != csm.getNumBands()) {
	return false;
	}

	int[] bandOffsets = csm.getBandOffsets();
	for (int i = 0; i < bandOffsets.length; i++) {
	if (bandOffsets[i] != i) {
	return false;
	}
	}

	int[] bankIndices = csm.getBankIndices();
	for (int i = 0; i < bandOffsets.length; i++) {
	if (bankIndices[i] != 0) {
	return false;
	}
	}

	return true;
	}

	// Otherwise true if and only if it's a bilevel image with
	// a MultiPixelPackedSampleModel, 1 bit per pixel, and 1 bit
	// pixel stride.
	return ImageUtil.isBinary(sm);
	}
	}

Back to index...