/*
* Copyright (c) 1997, 2008, 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 java.awt.image;
import java.awt.Transparency;
import java.awt.color.ColorSpace;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsEnvironment;
import java.awt.ImageCapabilities;
import java.awt.geom.Rectangle2D;
import java.awt.geom.Point2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Hashtable;
import java.util.Vector;
import sun.awt.image.BytePackedRaster;
import sun.awt.image.ShortComponentRaster;
import sun.awt.image.ByteComponentRaster;
import sun.awt.image.IntegerComponentRaster;
import sun.awt.image.OffScreenImageSource;
/**
*
* The <code>BufferedImage</code> subclass describes an {@link
* java.awt.Image Image} with an accessible buffer of image data.
* A <code>BufferedImage</code> is comprised of a {@link ColorModel} and a
* {@link Raster} of image data.
* The number and types of bands in the {@link SampleModel} of the
* <code>Raster</code> must match the number and types required by the
* <code>ColorModel</code> to represent its color and alpha components.
* All <code>BufferedImage</code> objects have an upper left corner
* coordinate of (0, 0). Any <code>Raster</code> used to construct a
* <code>BufferedImage</code> must therefore have minX=0 and minY=0.
*
* <p>
* This class relies on the data fetching and setting methods
* of <code>Raster</code>,
* and on the color characterization methods of <code>ColorModel</code>.
*
* @see ColorModel
* @see Raster
* @see WritableRaster
*/
public class BufferedImage extends java.awt.Image
implements WritableRenderedImage, Transparency
{
int imageType = TYPE_CUSTOM;
ColorModel colorModel;
WritableRaster raster;
OffScreenImageSource osis;
Hashtable properties;
boolean isAlphaPremultiplied;// If true, alpha has been premultiplied in
// color channels
/**
* Image Type Constants
*/
/**
* Image type is not recognized so it must be a customized
* image. This type is only used as a return value for the getType()
* method.
*/
public static final int TYPE_CUSTOM = 0;
/**
* Represents an image with 8-bit RGB color components packed into
* integer pixels. The image has a {@link DirectColorModel} without
* alpha.
* When data with non-opaque alpha is stored
* in an image of this type,
* the color data must be adjusted to a non-premultiplied form
* and the alpha discarded,
* as described in the
* {@link java.awt.AlphaComposite} documentation.
*/
public static final int TYPE_INT_RGB = 1;
/**
* Represents an image with 8-bit RGBA color components packed into
* integer pixels. The image has a <code>DirectColorModel</code>
* with alpha. The color data in this image is considered not to be
* premultiplied with alpha. When this type is used as the
* <code>imageType</code> argument to a <code>BufferedImage</code>
* constructor, the created image is consistent with images
* created in the JDK1.1 and earlier releases.
*/
public static final int TYPE_INT_ARGB = 2;
/**
* Represents an image with 8-bit RGBA color components packed into
* integer pixels. The image has a <code>DirectColorModel</code>
* with alpha. The color data in this image is considered to be
* premultiplied with alpha.
*/
public static final int TYPE_INT_ARGB_PRE = 3;
/**
* Represents an image with 8-bit RGB color components, corresponding
* to a Windows- or Solaris- style BGR color model, with the colors
* Blue, Green, and Red packed into integer pixels. There is no alpha.
* The image has a {@link DirectColorModel}.
* When data with non-opaque alpha is stored
* in an image of this type,
* the color data must be adjusted to a non-premultiplied form
* and the alpha discarded,
* as described in the
* {@link java.awt.AlphaComposite} documentation.
*/
public static final int TYPE_INT_BGR = 4;
/**
* Represents an image with 8-bit RGB color components, corresponding
* to a Windows-style BGR color model) with the colors Blue, Green,
* and Red stored in 3 bytes. There is no alpha. The image has a
* <code>ComponentColorModel</code>.
* When data with non-opaque alpha is stored
* in an image of this type,
* the color data must be adjusted to a non-premultiplied form
* and the alpha discarded,
* as described in the
* {@link java.awt.AlphaComposite} documentation.
*/
public static final int TYPE_3BYTE_BGR = 5;
/**
* Represents an image with 8-bit RGBA color components with the colors
* Blue, Green, and Red stored in 3 bytes and 1 byte of alpha. The
* image has a <code>ComponentColorModel</code> with alpha. The
* color data in this image is considered not to be premultiplied with
* alpha. The byte data is interleaved in a single
* byte array in the order A, B, G, R
* from lower to higher byte addresses within each pixel.
*/
public static final int TYPE_4BYTE_ABGR = 6;
/**
* Represents an image with 8-bit RGBA color components with the colors
* Blue, Green, and Red stored in 3 bytes and 1 byte of alpha. The
* image has a <code>ComponentColorModel</code> with alpha. The color
* data in this image is considered to be premultiplied with alpha.
* The byte data is interleaved in a single byte array in the order
* A, B, G, R from lower to higher byte addresses within each pixel.
*/
public static final int TYPE_4BYTE_ABGR_PRE = 7;
/**
* Represents an image with 5-6-5 RGB color components (5-bits red,
* 6-bits green, 5-bits blue) with no alpha. This image has
* a <code>DirectColorModel</code>.
* When data with non-opaque alpha is stored
* in an image of this type,
* the color data must be adjusted to a non-premultiplied form
* and the alpha discarded,
* as described in the
* {@link java.awt.AlphaComposite} documentation.
*/
public static final int TYPE_USHORT_565_RGB = 8;
/**
* Represents an image with 5-5-5 RGB color components (5-bits red,
* 5-bits green, 5-bits blue) with no alpha. This image has
* a <code>DirectColorModel</code>.
* When data with non-opaque alpha is stored
* in an image of this type,
* the color data must be adjusted to a non-premultiplied form
* and the alpha discarded,
* as described in the
* {@link java.awt.AlphaComposite} documentation.
*/
public static final int TYPE_USHORT_555_RGB = 9;
/**
* Represents a unsigned byte grayscale image, non-indexed. This
* image has a <code>ComponentColorModel</code> with a CS_GRAY
* {@link ColorSpace}.
* When data with non-opaque alpha is stored
* in an image of this type,
* the color data must be adjusted to a non-premultiplied form
* and the alpha discarded,
* as described in the
* {@link java.awt.AlphaComposite} documentation.
*/
public static final int TYPE_BYTE_GRAY = 10;
/**
* Represents an unsigned short grayscale image, non-indexed). This
* image has a <code>ComponentColorModel</code> with a CS_GRAY
* <code>ColorSpace</code>.
* When data with non-opaque alpha is stored
* in an image of this type,
* the color data must be adjusted to a non-premultiplied form
* and the alpha discarded,
* as described in the
* {@link java.awt.AlphaComposite} documentation.
*/
public static final int TYPE_USHORT_GRAY = 11;
/**
* Represents an opaque byte-packed 1, 2, or 4 bit image. The
* image has an {@link IndexColorModel} without alpha. When this
* type is used as the <code>imageType</code> argument to the
* <code>BufferedImage</code> constructor that takes an
* <code>imageType</code> argument but no <code>ColorModel</code>
* argument, a 1-bit image is created with an
* <code>IndexColorModel</code> with two colors in the default
* sRGB <code>ColorSpace</code>: {0, 0, 0} and
* {255, 255, 255}.
*
* <p> Images with 2 or 4 bits per pixel may be constructed via
* the <code>BufferedImage</code> constructor that takes a
* <code>ColorModel</code> argument by supplying a
* <code>ColorModel</code> with an appropriate map size.
*
* <p> Images with 8 bits per pixel should use the image types
* <code>TYPE_BYTE_INDEXED</code> or <code>TYPE_BYTE_GRAY</code>
* depending on their <code>ColorModel</code>.
* <p> When color data is stored in an image of this type,
* the closest color in the colormap is determined
* by the <code>IndexColorModel</code> and the resulting index is stored.
* Approximation and loss of alpha or color components
* can result, depending on the colors in the
* <code>IndexColorModel</code> colormap.
*/
public static final int TYPE_BYTE_BINARY = 12;
/**
* Represents an indexed byte image. When this type is used as the
* <code>imageType</code> argument to the <code>BufferedImage</code>
* constructor that takes an <code>imageType</code> argument
* but no <code>ColorModel</code> argument, an
* <code>IndexColorModel</code> is created with
* a 256-color 6/6/6 color cube palette with the rest of the colors
* from 216-255 populated by grayscale values in the
* default sRGB ColorSpace.
*
* <p> When color data is stored in an image of this type,
* the closest color in the colormap is determined
* by the <code>IndexColorModel</code> and the resulting index is stored.
* Approximation and loss of alpha or color components
* can result, depending on the colors in the
* <code>IndexColorModel</code> colormap.
*/
public static final int TYPE_BYTE_INDEXED = 13;
private static final int DCM_RED_MASK = 0x00ff0000;
private static final int DCM_GREEN_MASK = 0x0000ff00;
private static final int DCM_BLUE_MASK = 0x000000ff;
private static final int DCM_ALPHA_MASK = 0xff000000;
private static final int DCM_565_RED_MASK = 0xf800;
private static final int DCM_565_GRN_MASK = 0x07E0;
private static final int DCM_565_BLU_MASK = 0x001F;
private static final int DCM_555_RED_MASK = 0x7C00;
private static final int DCM_555_GRN_MASK = 0x03E0;
private static final int DCM_555_BLU_MASK = 0x001F;
private static final int DCM_BGR_RED_MASK = 0x0000ff;
private static final int DCM_BGR_GRN_MASK = 0x00ff00;
private static final int DCM_BGR_BLU_MASK = 0xff0000;
static private native void initIDs();
static {
ColorModel.loadLibraries();
initIDs();
}
/**
* Constructs a <code>BufferedImage</code> of one of the predefined
* image types. The <code>ColorSpace</code> for the image is the
* default sRGB space.
* @param width width of the created image
* @param height height of the created image
* @param imageType type of the created image
* @see ColorSpace
* @see #TYPE_INT_RGB
* @see #TYPE_INT_ARGB
* @see #TYPE_INT_ARGB_PRE
* @see #TYPE_INT_BGR
* @see #TYPE_3BYTE_BGR
* @see #TYPE_4BYTE_ABGR
* @see #TYPE_4BYTE_ABGR_PRE
* @see #TYPE_BYTE_GRAY
* @see #TYPE_USHORT_GRAY
* @see #TYPE_BYTE_BINARY
* @see #TYPE_BYTE_INDEXED
* @see #TYPE_USHORT_565_RGB
* @see #TYPE_USHORT_555_RGB
*/
public BufferedImage(int width,
int height,
int imageType) {
switch (imageType) {
case TYPE_INT_RGB:
{
colorModel = new DirectColorModel(24,
0x00ff0000, // Red
0x0000ff00, // Green
0x000000ff, // Blue
0x0 // Alpha
);
raster = colorModel.createCompatibleWritableRaster(width,
height);
}
break;
case TYPE_INT_ARGB:
{
colorModel = ColorModel.getRGBdefault();
raster = colorModel.createCompatibleWritableRaster(width,
height);
}
break;
case TYPE_INT_ARGB_PRE:
{
colorModel = new
DirectColorModel(
ColorSpace.getInstance(ColorSpace.CS_sRGB),
32,
0x00ff0000,// Red
0x0000ff00,// Green
0x000000ff,// Blue
0xff000000,// Alpha
true, // Alpha Premultiplied
DataBuffer.TYPE_INT
);
raster = colorModel.createCompatibleWritableRaster(width,
height);
}
break;
case TYPE_INT_BGR:
{
colorModel = new DirectColorModel(24,
0x000000ff, // Red
0x0000ff00, // Green
0x00ff0000 // Blue
);
raster = colorModel.createCompatibleWritableRaster(width,
height);
}
break;
case TYPE_3BYTE_BGR:
{
ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
int[] nBits = {8, 8, 8};
int[] bOffs = {2, 1, 0};
colorModel = new ComponentColorModel(cs, nBits, false, false,
Transparency.OPAQUE,
DataBuffer.TYPE_BYTE);
raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,
width, height,
width*3, 3,
bOffs, null);
}
break;
case TYPE_4BYTE_ABGR:
{
ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
int[] nBits = {8, 8, 8, 8};
int[] bOffs = {3, 2, 1, 0};
colorModel = new ComponentColorModel(cs, nBits, true, false,
Transparency.TRANSLUCENT,
DataBuffer.TYPE_BYTE);
raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,
width, height,
width*4, 4,
bOffs, null);
}
break;
case TYPE_4BYTE_ABGR_PRE:
{
ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
int[] nBits = {8, 8, 8, 8};
int[] bOffs = {3, 2, 1, 0};
colorModel = new ComponentColorModel(cs, nBits, true, true,
Transparency.TRANSLUCENT,
DataBuffer.TYPE_BYTE);
raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,
width, height,
width*4, 4,
bOffs, null);
}
break;
case TYPE_BYTE_GRAY:
{
ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_GRAY);
int[] nBits = {8};
colorModel = new ComponentColorModel(cs, nBits, false, true,
Transparency.OPAQUE,
DataBuffer.TYPE_BYTE);
raster = colorModel.createCompatibleWritableRaster(width,
height);
}
break;
case TYPE_USHORT_GRAY:
{
ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_GRAY);
int[] nBits = {16};
colorModel = new ComponentColorModel(cs, nBits, false, true,
Transparency.OPAQUE,
DataBuffer.TYPE_USHORT);
raster = colorModel.createCompatibleWritableRaster(width,
height);
}
break;
case TYPE_BYTE_BINARY:
{
byte[] arr = {(byte)0, (byte)0xff};
colorModel = new IndexColorModel(1, 2, arr, arr, arr);
raster = Raster.createPackedRaster(DataBuffer.TYPE_BYTE,
width, height, 1, 1, null);
}
break;
case TYPE_BYTE_INDEXED:
{
// Create a 6x6x6 color cube
int[] cmap = new int[256];
int i=0;
for (int r=0; r < 256; r += 51) {
for (int g=0; g < 256; g += 51) {
for (int b=0; b < 256; b += 51) {
cmap[i++] = (r<<16)|(g<<8)|b;
}
}
}
// And populate the rest of the cmap with gray values
int grayIncr = 256/(256-i);
// The gray ramp will be between 18 and 252
int gray = grayIncr*3;
for (; i < 256; i++) {
cmap[i] = (gray<<16)|(gray<<8)|gray;
gray += grayIncr;
}
colorModel = new IndexColorModel(8, 256, cmap, 0, false, -1,
DataBuffer.TYPE_BYTE);
raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,
width, height, 1, null);
}
break;
case TYPE_USHORT_565_RGB:
{
colorModel = new DirectColorModel(16,
DCM_565_RED_MASK,
DCM_565_GRN_MASK,
DCM_565_BLU_MASK
);
raster = colorModel.createCompatibleWritableRaster(width,
height);
}
break;
case TYPE_USHORT_555_RGB:
{
colorModel = new DirectColorModel(15,
DCM_555_RED_MASK,
DCM_555_GRN_MASK,
DCM_555_BLU_MASK
);
raster = colorModel.createCompatibleWritableRaster(width,
height);
}
break;
default:
throw new IllegalArgumentException ("Unknown image type " +
imageType);
}
this.imageType = imageType;
}
/**
* Constructs a <code>BufferedImage</code> of one of the predefined
* image types:
* TYPE_BYTE_BINARY or TYPE_BYTE_INDEXED.
*
* <p> If the image type is TYPE_BYTE_BINARY, the number of
* entries in the color model is used to determine whether the
* image should have 1, 2, or 4 bits per pixel. If the color model
* has 1 or 2 entries, the image will have 1 bit per pixel. If it
* has 3 or 4 entries, the image with have 2 bits per pixel. If
* it has between 5 and 16 entries, the image will have 4 bits per
* pixel. Otherwise, an IllegalArgumentException will be thrown.
*
* @param width width of the created image
* @param height height of the created image
* @param imageType type of the created image
* @param cm <code>IndexColorModel</code> of the created image
* @throws IllegalArgumentException if the imageType is not
* TYPE_BYTE_BINARY or TYPE_BYTE_INDEXED or if the imageType is
* TYPE_BYTE_BINARY and the color map has more than 16 entries.
* @see #TYPE_BYTE_BINARY
* @see #TYPE_BYTE_INDEXED
*/
public BufferedImage (int width,
int height,
int imageType,
IndexColorModel cm) {
if (cm.hasAlpha() && cm.isAlphaPremultiplied()) {
throw new IllegalArgumentException("This image types do not have "+
"premultiplied alpha.");
}
switch(imageType) {
case TYPE_BYTE_BINARY:
int bits; // Will be set below
int mapSize = cm.getMapSize();
if (mapSize <= 2) {
bits = 1;
} else if (mapSize <= 4) {
bits = 2;
} else if (mapSize <= 16) {
bits = 4;
} else {
throw new IllegalArgumentException
("Color map for TYPE_BYTE_BINARY " +
"must have no more than 16 entries");
}
raster = Raster.createPackedRaster(DataBuffer.TYPE_BYTE,
width, height, 1, bits, null);
break;
case TYPE_BYTE_INDEXED:
raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,
width, height, 1, null);
break;
default:
throw new IllegalArgumentException("Invalid image type (" +
imageType+"). Image type must"+
" be either TYPE_BYTE_BINARY or "+
" TYPE_BYTE_INDEXED");
}
if (!cm.isCompatibleRaster(raster)) {
throw new IllegalArgumentException("Incompatible image type and IndexColorModel");
}
colorModel = cm;
this.imageType = imageType;
}
/**
* Constructs a new <code>BufferedImage</code> with a specified
* <code>ColorModel</code> and <code>Raster</code>. If the number and
* types of bands in the <code>SampleModel</code> of the
* <code>Raster</code> do not match the number and types required by
* the <code>ColorModel</code> to represent its color and alpha
* components, a {@link RasterFormatException} is thrown. This
* method can multiply or divide the color <code>Raster</code> data by
* alpha to match the <code>alphaPremultiplied</code> state
* in the <code>ColorModel</code>. Properties for this
* <code>BufferedImage</code> can be established by passing
* in a {@link Hashtable} of <code>String</code>/<code>Object</code>
* pairs.
* @param cm <code>ColorModel</code> for the new image
* @param raster <code>Raster</code> for the image data
* @param isRasterPremultiplied if <code>true</code>, the data in
* the raster has been premultiplied with alpha.
* @param properties <code>Hashtable</code> of
* <code>String</code>/<code>Object</code> pairs.
* @exception RasterFormatException if the number and
* types of bands in the <code>SampleModel</code> of the
* <code>Raster</code> do not match the number and types required by
* the <code>ColorModel</code> to represent its color and alpha
* components.
* @exception IllegalArgumentException if
* <code>raster</code> is incompatible with <code>cm</code>
* @see ColorModel
* @see Raster
* @see WritableRaster
*/
/*
*
* FOR NOW THE CODE WHICH DEFINES THE RASTER TYPE IS DUPLICATED BY DVF
* SEE THE METHOD DEFINERASTERTYPE @ RASTEROUTPUTMANAGER
*
*/
public BufferedImage (ColorModel cm,
WritableRaster raster,
boolean isRasterPremultiplied,
Hashtable<?,?> properties) {
if (!cm.isCompatibleRaster(raster)) {
throw new
IllegalArgumentException("Raster "+raster+
" is incompatible with ColorModel "+
cm);
}
if ((raster.minX != 0) || (raster.minY != 0)) {
throw new
IllegalArgumentException("Raster "+raster+
" has minX or minY not equal to zero: "
+ raster.minX + " " + raster.minY);
}
colorModel = cm;
this.raster = raster;
this.properties = properties;
int numBands = raster.getNumBands();
boolean isAlphaPre = cm.isAlphaPremultiplied();
final boolean isStandard = isStandard(cm, raster);
ColorSpace cs;
// Force the raster data alpha state to match the premultiplied
// state in the color model
coerceData(isRasterPremultiplied);
SampleModel sm = raster.getSampleModel();
cs = cm.getColorSpace();
int csType = cs.getType();
if (csType != ColorSpace.TYPE_RGB) {
if (csType == ColorSpace.TYPE_GRAY &&
isStandard &&
cm instanceof ComponentColorModel) {
// Check if this might be a child raster (fix for bug 4240596)
if (sm instanceof ComponentSampleModel &&
((ComponentSampleModel)sm).getPixelStride() != numBands) {
imageType = TYPE_CUSTOM;
} else if (raster instanceof ByteComponentRaster &&
raster.getNumBands() == 1 &&
cm.getComponentSize(0) == 8 &&
((ByteComponentRaster)raster).getPixelStride() == 1) {
imageType = TYPE_BYTE_GRAY;
} else if (raster instanceof ShortComponentRaster &&
raster.getNumBands() == 1 &&
cm.getComponentSize(0) == 16 &&
((ShortComponentRaster)raster).getPixelStride() == 1) {
imageType = TYPE_USHORT_GRAY;
}
} else {
imageType = TYPE_CUSTOM;
}
return;
}
if ((raster instanceof IntegerComponentRaster) &&
(numBands == 3 || numBands == 4)) {
IntegerComponentRaster iraster =
(IntegerComponentRaster) raster;
// Check if the raster params and the color model
// are correct
int pixSize = cm.getPixelSize();
if (iraster.getPixelStride() == 1 &&
isStandard &&
cm instanceof DirectColorModel &&
(pixSize == 32 || pixSize == 24))
{
// Now check on the DirectColorModel params
DirectColorModel dcm = (DirectColorModel) cm;
int rmask = dcm.getRedMask();
int gmask = dcm.getGreenMask();
int bmask = dcm.getBlueMask();
if (rmask == DCM_RED_MASK && gmask == DCM_GREEN_MASK &&
bmask == DCM_BLUE_MASK)
{
if (dcm.getAlphaMask() == DCM_ALPHA_MASK) {
imageType = (isAlphaPre
? TYPE_INT_ARGB_PRE
: TYPE_INT_ARGB);
}
else {
// No Alpha
if (!dcm.hasAlpha()) {
imageType = TYPE_INT_RGB;
}
}
} // if (dcm.getRedMask() == DCM_RED_MASK &&
else if (rmask == DCM_BGR_RED_MASK && gmask == DCM_BGR_GRN_MASK
&& bmask == DCM_BGR_BLU_MASK) {
if (!dcm.hasAlpha()) {
imageType = TYPE_INT_BGR;
}
} // if (rmask == DCM_BGR_RED_MASK &&
} // if (iraster.getPixelStride() == 1
} // ((raster instanceof IntegerComponentRaster) &&
else if ((cm instanceof IndexColorModel) && (numBands == 1) &&
isStandard &&
(!cm.hasAlpha() || !isAlphaPre))
{
IndexColorModel icm = (IndexColorModel) cm;
int pixSize = icm.getPixelSize();
if (raster instanceof BytePackedRaster) {
imageType = TYPE_BYTE_BINARY;
} // if (raster instanceof BytePackedRaster)
else if (raster instanceof ByteComponentRaster) {
ByteComponentRaster braster = (ByteComponentRaster) raster;
if (braster.getPixelStride() == 1 && pixSize <= 8) {
imageType = TYPE_BYTE_INDEXED;
}
}
} // else if (cm instanceof IndexColorModel) && (numBands == 1))
else if ((raster instanceof ShortComponentRaster)
&& (cm instanceof DirectColorModel)
&& isStandard
&& (numBands == 3)
&& !cm.hasAlpha())
{
DirectColorModel dcm = (DirectColorModel) cm;
if (dcm.getRedMask() == DCM_565_RED_MASK) {
if (dcm.getGreenMask() == DCM_565_GRN_MASK &&
dcm.getBlueMask() == DCM_565_BLU_MASK) {
imageType = TYPE_USHORT_565_RGB;
}
}
else if (dcm.getRedMask() == DCM_555_RED_MASK) {
if (dcm.getGreenMask() == DCM_555_GRN_MASK &&
dcm.getBlueMask() == DCM_555_BLU_MASK) {
imageType = TYPE_USHORT_555_RGB;
}
}
} // else if ((cm instanceof IndexColorModel) && (numBands == 1))
else if ((raster instanceof ByteComponentRaster)
&& (cm instanceof ComponentColorModel)
&& isStandard
&& (raster.getSampleModel() instanceof PixelInterleavedSampleModel)
&& (numBands == 3 || numBands == 4))
{
ComponentColorModel ccm = (ComponentColorModel) cm;
PixelInterleavedSampleModel csm =
(PixelInterleavedSampleModel)raster.getSampleModel();
ByteComponentRaster braster = (ByteComponentRaster) raster;
int[] offs = csm.getBandOffsets();
if (ccm.getNumComponents() != numBands) {
throw new RasterFormatException("Number of components in "+
"ColorModel ("+
ccm.getNumComponents()+
") does not match # in "+
" Raster ("+numBands+")");
}
int[] nBits = ccm.getComponentSize();
boolean is8bit = true;
for (int i=0; i < numBands; i++) {
if (nBits[i] != 8) {
is8bit = false;
break;
}
}
if (is8bit &&
braster.getPixelStride() == numBands &&
offs[0] == numBands-1 &&
offs[1] == numBands-2 &&
offs[2] == numBands-3)
{
if (numBands == 3 && !ccm.hasAlpha()) {
imageType = TYPE_3BYTE_BGR;
}
else if (offs[3] == 0 && ccm.hasAlpha()) {
imageType = (isAlphaPre
? TYPE_4BYTE_ABGR_PRE
: TYPE_4BYTE_ABGR);
}
}
} // else if ((raster instanceof ByteComponentRaster) &&
}
private static boolean isStandard(ColorModel cm, WritableRaster wr) {
final Class<? extends ColorModel> cmClass = cm.getClass();
final Class<? extends WritableRaster> wrClass = wr.getClass();
final Class<? extends SampleModel> smClass = wr.getSampleModel().getClass();
final PrivilegedAction<Boolean> checkClassLoadersAction =
new PrivilegedAction<Boolean>()
{
@Override
public Boolean run() {
final ClassLoader std = System.class.getClassLoader();
return (cmClass.getClassLoader() == std) &&
(smClass.getClassLoader() == std) &&
(wrClass.getClassLoader() == std);
}
};
return AccessController.doPrivileged(checkClassLoadersAction);
}
/**
* Returns the image type. If it is not one of the known types,
* TYPE_CUSTOM is returned.
* @return the image type of this <code>BufferedImage</code>.
* @see #TYPE_INT_RGB
* @see #TYPE_INT_ARGB
* @see #TYPE_INT_ARGB_PRE
* @see #TYPE_INT_BGR
* @see #TYPE_3BYTE_BGR
* @see #TYPE_4BYTE_ABGR
* @see #TYPE_4BYTE_ABGR_PRE
* @see #TYPE_BYTE_GRAY
* @see #TYPE_BYTE_BINARY
* @see #TYPE_BYTE_INDEXED
* @see #TYPE_USHORT_GRAY
* @see #TYPE_USHORT_565_RGB
* @see #TYPE_USHORT_555_RGB
* @see #TYPE_CUSTOM
*/
public int getType() {
return imageType;
}
/**
* Returns the <code>ColorModel</code>.
* @return the <code>ColorModel</code> of this
* <code>BufferedImage</code>.
*/
public ColorModel getColorModel() {
return colorModel;
}
/**
* Returns the {@link WritableRaster}.
* @return the <code>WriteableRaster</code> of this
* <code>BufferedImage</code>.
*/
public WritableRaster getRaster() {
return raster;
}
/**
* Returns a <code>WritableRaster</code> representing the alpha
* channel for <code>BufferedImage</code> objects
* with <code>ColorModel</code> objects that support a separate
* spatial alpha channel, such as <code>ComponentColorModel</code> and
* <code>DirectColorModel</code>. Returns <code>null</code> if there
* is no alpha channel associated with the <code>ColorModel</code> in
* this image. This method assumes that for all
* <code>ColorModel</code> objects other than
* <code>IndexColorModel</code>, if the <code>ColorModel</code>
* supports alpha, there is a separate alpha channel
* which is stored as the last band of image data.
* If the image uses an <code>IndexColorModel</code> that
* has alpha in the lookup table, this method returns
* <code>null</code> since there is no spatially discrete alpha
* channel. This method creates a new
* <code>WritableRaster</code>, but shares the data array.
* @return a <code>WritableRaster</code> or <code>null</code> if this
* <code>BufferedImage</code> has no alpha channel associated
* with its <code>ColorModel</code>.
*/
public WritableRaster getAlphaRaster() {
return colorModel.getAlphaRaster(raster);
}
/**
* Returns an integer pixel in the default RGB color model
* (TYPE_INT_ARGB) and default sRGB colorspace. Color
* conversion takes place if this default model does not match
* the image <code>ColorModel</code>. There are only 8-bits of
* precision for each color component in the returned data when using
* this method.
*
* <p>
*
* An <code>ArrayOutOfBoundsException</code> 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 from which to get
* the pixel in the default RGB color model and sRGB
* color space
* @param y the Y coordinate of the pixel from which to get
* the pixel in the default RGB color model and sRGB
* color space
* @return an integer pixel in the default RGB color model and
* default sRGB colorspace.
* @see #setRGB(int, int, int)
* @see #setRGB(int, int, int, int, int[], int, int)
*/
public int getRGB(int x, int y) {
return colorModel.getRGB(raster.getDataElements(x, y, null));
}
/**
* Returns an array of integer pixels in the default RGB color model
* (TYPE_INT_ARGB) and default sRGB color space,
* from a portion of the image data. Color conversion takes
* place if the default model does not match the image
* <code>ColorModel</code>. There are only 8-bits of precision for
* each color component in the returned data when
* using this method. With a specified coordinate (x, y) in the
* image, the ARGB pixel can be accessed in this way:
* <p>
*
* <pre>
* pixel = rgbArray[offset + (y-startY)*scansize + (x-startX)]; </pre>
*
* <p>
*
* An <code>ArrayOutOfBoundsException</code> may be thrown
* if the region is not in bounds.
* However, explicit bounds checking is not guaranteed.
*
* @param startX the starting X coordinate
* @param startY the starting Y coordinate
* @param w width of region
* @param h height of region
* @param rgbArray if not <code>null</code>, the rgb pixels are
* written here
* @param offset offset into the <code>rgbArray</code>
* @param scansize scanline stride for the <code>rgbArray</code>
* @return array of RGB pixels.
* @see #setRGB(int, int, int)
* @see #setRGB(int, int, int, int, int[], int, int)
*/
public int[] getRGB(int startX, int startY, int w, int h,
int[] rgbArray, int offset, int scansize) {
int yoff = offset;
int off;
Object data;
int nbands = raster.getNumBands();
int dataType = raster.getDataBuffer().getDataType();
switch (dataType) {
case DataBuffer.TYPE_BYTE:
data = new byte[nbands];
break;
case DataBuffer.TYPE_USHORT:
data = new short[nbands];
break;
case DataBuffer.TYPE_INT:
data = new int[nbands];
break;
case DataBuffer.TYPE_FLOAT:
data = new float[nbands];
break;
case DataBuffer.TYPE_DOUBLE:
data = new double[nbands];
break;
default:
throw new IllegalArgumentException("Unknown data buffer type: "+
dataType);
}
if (rgbArray == null) {
rgbArray = new int[offset+h*scansize];
}
for (int y = startY; y < startY+h; y++, yoff+=scansize) {
off = yoff;
for (int x = startX; x < startX+w; x++) {
rgbArray[off++] = colorModel.getRGB(raster.getDataElements(x,
y,
data));
}
}
return rgbArray;
}
/**
* Sets a pixel in this <code>BufferedImage</code> to the specified
* RGB value. The pixel is assumed to be in the default RGB color
* model, TYPE_INT_ARGB, and default sRGB color space. For images
* with an <code>IndexColorModel</code>, the index with the nearest
* color is chosen.
*
* <p>
*
* An <code>ArrayOutOfBoundsException</code> 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 to set
* @param y the Y coordinate of the pixel to set
* @param rgb the RGB value
* @see #getRGB(int, int)
* @see #getRGB(int, int, int, int, int[], int, int)
*/
public synchronized void setRGB(int x, int y, int rgb) {
raster.setDataElements(x, y, colorModel.getDataElements(rgb, null));
}
/**
* Sets an array of integer pixels in the default RGB color model
* (TYPE_INT_ARGB) and default sRGB color space,
* into a portion of the image data. Color conversion takes place
* if the default model does not match the image
* <code>ColorModel</code>. There are only 8-bits of precision for
* each color component in the returned data when
* using this method. With a specified coordinate (x, y) in the
* this image, the ARGB pixel can be accessed in this way:
* <pre>
* pixel = rgbArray[offset + (y-startY)*scansize + (x-startX)];
* </pre>
* WARNING: No dithering takes place.
*
* <p>
*
* An <code>ArrayOutOfBoundsException</code> may be thrown
* if the region is not in bounds.
* However, explicit bounds checking is not guaranteed.
*
* @param startX the starting X coordinate
* @param startY the starting Y coordinate
* @param w width of the region
* @param h height of the region
* @param rgbArray the rgb pixels
* @param offset offset into the <code>rgbArray</code>
* @param scansize scanline stride for the <code>rgbArray</code>
* @see #getRGB(int, int)
* @see #getRGB(int, int, int, int, int[], int, int)
*/
public void setRGB(int startX, int startY, int w, int h,
int[] rgbArray, int offset, int scansize) {
int yoff = offset;
int off;
Object pixel = null;
for (int y = startY; y < startY+h; y++, yoff+=scansize) {
off = yoff;
for (int x = startX; x < startX+w; x++) {
pixel = colorModel.getDataElements(rgbArray[off++], pixel);
raster.setDataElements(x, y, pixel);
}
}
}
/**
* Returns the width of the <code>BufferedImage</code>.
* @return the width of this <code>BufferedImage</code>
*/
public int getWidth() {
return raster.getWidth();
}
/**
* Returns the height of the <code>BufferedImage</code>.
* @return the height of this <code>BufferedImage</code>
*/
public int getHeight() {
return raster.getHeight();
}
/**
* Returns the width of the <code>BufferedImage</code>.
* @param observer ignored
* @return the width of this <code>BufferedImage</code>
*/
public int getWidth(ImageObserver observer) {
return raster.getWidth();
}
/**
* Returns the height of the <code>BufferedImage</code>.
* @param observer ignored
* @return the height of this <code>BufferedImage</code>
*/
public int getHeight(ImageObserver observer) {
return raster.getHeight();
}
/**
* Returns the object that produces the pixels for the image.
* @return the {@link ImageProducer} that is used to produce the
* pixels for this image.
* @see ImageProducer
*/
public ImageProducer getSource() {
if (osis == null) {
if (properties == null) {
properties = new Hashtable();
}
osis = new OffScreenImageSource(this, properties);
}
return osis;
}
/**
* Returns a property of the image by name. Individual property names
* are defined by the various image formats. If a property is not
* defined for a particular image, this method returns the
* <code>UndefinedProperty</code> field. If the properties
* for this image are not yet known, then this method returns
* <code>null</code> and the <code>ImageObserver</code> object is
* notified later. The property name "comment" should be used to
* store an optional comment that can be presented to the user as a
* description of the image, its source, or its author.
* @param name the property name
* @param observer the <code>ImageObserver</code> that receives
* notification regarding image information
* @return an {@link Object} that is the property referred to by the
* specified <code>name</code> or <code>null</code> if the
* properties of this image are not yet known.
* @throws NullPointerException if the property name is null.
* @see ImageObserver
* @see java.awt.Image#UndefinedProperty
*/
public Object getProperty(String name, ImageObserver observer) {
return getProperty(name);
}
/**
* Returns a property of the image by name.
* @param name the property name
* @return an <code>Object</code> that is the property referred to by
* the specified <code>name</code>.
* @throws NullPointerException if the property name is null.
*/
public Object getProperty(String name) {
if (name == null) {
throw new NullPointerException("null property name is not allowed");
}
if (properties == null) {
return java.awt.Image.UndefinedProperty;
}
Object o = properties.get(name);
if (o == null) {
o = java.awt.Image.UndefinedProperty;
}
return o;
}
/**
* This method returns a {@link Graphics2D}, but is here
* for backwards compatibility. {@link #createGraphics() createGraphics} is more
* convenient, since it is declared to return a
* <code>Graphics2D</code>.
* @return a <code>Graphics2D</code>, which can be used to draw into
* this image.
*/
public java.awt.Graphics getGraphics() {
return createGraphics();
}
/**
* Creates a <code>Graphics2D</code>, which can be used to draw into
* this <code>BufferedImage</code>.
* @return a <code>Graphics2D</code>, used for drawing into this
* image.
*/
public Graphics2D createGraphics() {
GraphicsEnvironment env =
GraphicsEnvironment.getLocalGraphicsEnvironment();
return env.createGraphics(this);
}
/**
* Returns a subimage defined by a specified rectangular region.
* The returned <code>BufferedImage</code> shares the same
* data array as the original image.
* @param x the X coordinate of the upper-left corner of the
* specified rectangular region
* @param y the Y coordinate of the upper-left corner of the
* specified rectangular region
* @param w the width of the specified rectangular region
* @param h the height of the specified rectangular region
* @return a <code>BufferedImage</code> that is the subimage of this
* <code>BufferedImage</code>.
* @exception RasterFormatException if the specified
* area is not contained within this <code>BufferedImage</code>.
*/
public BufferedImage getSubimage (int x, int y, int w, int h) {
return new BufferedImage (colorModel,
raster.createWritableChild(x, y, w, h,
0, 0, null),
colorModel.isAlphaPremultiplied(),
properties);
}
/**
* Returns whether or not the alpha has been premultiplied. It
* returns <code>false</code> if there is no alpha.
* @return <code>true</code> if the alpha has been premultiplied;
* <code>false</code> otherwise.
*/
public boolean isAlphaPremultiplied() {
return colorModel.isAlphaPremultiplied();
}
/**
* Forces the data to match the state specified in the
* <code>isAlphaPremultiplied</code> variable. It may multiply or
* divide the color raster data by alpha, or do nothing if the data is
* in the correct state.
* @param isAlphaPremultiplied <code>true</code> if the alpha has been
* premultiplied; <code>false</code> otherwise.
*/
public void coerceData (boolean isAlphaPremultiplied) {
if (colorModel.hasAlpha() &&
colorModel.isAlphaPremultiplied() != isAlphaPremultiplied) {
// Make the color model do the conversion
colorModel = colorModel.coerceData (raster, isAlphaPremultiplied);
}
}
/**
* Returns a <code>String</code> representation of this
* <code>BufferedImage</code> object and its values.
* @return a <code>String</code> representing this
* <code>BufferedImage</code>.
*/
public String toString() {
return "BufferedImage@"+Integer.toHexString(hashCode())
+": type = "+imageType
+" "+colorModel+" "+raster;
}
/**
* Returns a {@link Vector} of {@link RenderedImage} objects that are
* the immediate sources, not the sources of these immediate sources,
* of image data for this <code>BufferedImage</code>. This
* method returns <code>null</code> if the <code>BufferedImage</code>
* has no information about its immediate sources. It returns an
* empty <code>Vector</code> if the <code>BufferedImage</code> has no
* immediate sources.
* @return a <code>Vector</code> containing immediate sources of
* this <code>BufferedImage</code> object's image date, or
* <code>null</code> if this <code>BufferedImage</code> has
* no information about its immediate sources, or an empty
* <code>Vector</code> if this <code>BufferedImage</code>
* has no immediate sources.
*/
public Vector<RenderedImage> getSources() {
return null;
}
/**
* Returns an array of names recognized by
* {@link #getProperty(String) getProperty(String)}
* or <code>null</code>, if no property names are recognized.
* @return a <code>String</code> array containing all of the property
* names that <code>getProperty(String)</code> recognizes;
* or <code>null</code> if no property names are recognized.
*/
public String[] getPropertyNames() {
return null;
}
/**
* Returns the minimum x coordinate of this
* <code>BufferedImage</code>. This is always zero.
* @return the minimum x coordinate of this
* <code>BufferedImage</code>.
*/
public int getMinX() {
return raster.getMinX();
}
/**
* Returns the minimum y coordinate of this
* <code>BufferedImage</code>. This is always zero.
* @return the minimum y coordinate of this
* <code>BufferedImage</code>.
*/
public int getMinY() {
return raster.getMinY();
}
/**
* Returns the <code>SampleModel</code> associated with this
* <code>BufferedImage</code>.
* @return the <code>SampleModel</code> of this
* <code>BufferedImage</code>.
*/
public SampleModel getSampleModel() {
return raster.getSampleModel();
}
/**
* Returns the number of tiles in the x direction.
* This is always one.
* @return the number of tiles in the x direction.
*/
public int getNumXTiles() {
return 1;
}
/**
* Returns the number of tiles in the y direction.
* This is always one.
* @return the number of tiles in the y direction.
*/
public int getNumYTiles() {
return 1;
}
/**
* Returns the minimum tile index in the x direction.
* This is always zero.
* @return the minimum tile index in the x direction.
*/
public int getMinTileX() {
return 0;
}
/**
* Returns the minimum tile index in the y direction.
* This is always zero.
* @return the mininum tile index in the y direction.
*/
public int getMinTileY() {
return 0;
}
/**
* Returns the tile width in pixels.
* @return the tile width in pixels.
*/
public int getTileWidth() {
return raster.getWidth();
}
/**
* Returns the tile height in pixels.
* @return the tile height in pixels.
*/
public int getTileHeight() {
return raster.getHeight();
}
/**
* Returns the x offset of the tile grid relative to the origin,
* For example, the x coordinate of the location of tile
* (0, 0). This is always zero.
* @return the x offset of the tile grid.
*/
public int getTileGridXOffset() {
return raster.getSampleModelTranslateX();
}
/**
* Returns the y offset of the tile grid relative to the origin,
* For example, the y coordinate of the location of tile
* (0, 0). This is always zero.
* @return the y offset of the tile grid.
*/
public int getTileGridYOffset() {
return raster.getSampleModelTranslateY();
}
/**
* Returns tile (<code>tileX</code>, <code>tileY</code>). Note
* that <code>tileX</code> and <code>tileY</code> are indices
* into the tile array, not pixel locations. The <code>Raster</code>
* that is returned is live, which means that it is updated if the
* image is changed.
* @param tileX the x index of the requested tile in the tile array
* @param tileY the y index of the requested tile in the tile array
* @return a <code>Raster</code> that is the tile defined by the
* arguments <code>tileX</code> and <code>tileY</code>.
* @exception ArrayIndexOutOfBoundsException if both
* <code>tileX</code> and <code>tileY</code> are not
* equal to 0
*/
public Raster getTile(int tileX, int tileY) {
if (tileX == 0 && tileY == 0) {
return raster;
}
throw new ArrayIndexOutOfBoundsException("BufferedImages only have"+
" one tile with index 0,0");
}
/**
* Returns the image as one large tile. The <code>Raster</code>
* returned is a copy of the image data is not updated if the
* image is changed.
* @return a <code>Raster</code> that is a copy of the image data.
* @see #setData(Raster)
*/
public Raster getData() {
// REMIND : this allocates a whole new tile if raster is a
// subtile. (It only copies in the requested area)
// We should do something smarter.
int width = raster.getWidth();
int height = raster.getHeight();
int startX = raster.getMinX();
int startY = raster.getMinY();
WritableRaster wr =
Raster.createWritableRaster(raster.getSampleModel(),
new Point(raster.getSampleModelTranslateX(),
raster.getSampleModelTranslateY()));
Object tdata = null;
for (int i = startY; i < startY+height; i++) {
tdata = raster.getDataElements(startX,i,width,1,tdata);
wr.setDataElements(startX,i,width,1, tdata);
}
return wr;
}
/**
* Computes and returns an arbitrary region of the
* <code>BufferedImage</code>. The <code>Raster</code> returned is a
* copy of the image data and is not updated if the image is
* changed.
* @param rect the region of the <code>BufferedImage</code> to be
* returned.
* @return a <code>Raster</code> that is a copy of the image data of
* the specified region of the <code>BufferedImage</code>
* @see #setData(Raster)
*/
public Raster getData(Rectangle rect) {
SampleModel sm = raster.getSampleModel();
SampleModel nsm = sm.createCompatibleSampleModel(rect.width,
rect.height);
WritableRaster wr = Raster.createWritableRaster(nsm,
rect.getLocation());
int width = rect.width;
int height = rect.height;
int startX = rect.x;
int startY = rect.y;
Object tdata = null;
for (int i = startY; i < startY+height; i++) {
tdata = raster.getDataElements(startX,i,width,1,tdata);
wr.setDataElements(startX,i,width,1, tdata);
}
return wr;
}
/**
* Computes an arbitrary rectangular region of the
* <code>BufferedImage</code> and copies it into a specified
* <code>WritableRaster</code>. The region to be computed is
* determined from the bounds of the specified
* <code>WritableRaster</code>. The specified
* <code>WritableRaster</code> must have a
* <code>SampleModel</code> that is compatible with this image. If
* <code>outRaster</code> is <code>null</code>,
* an appropriate <code>WritableRaster</code> is created.
* @param outRaster a <code>WritableRaster</code> to hold the returned
* part of the image, or <code>null</code>
* @return a reference to the supplied or created
* <code>WritableRaster</code>.
*/
public WritableRaster copyData(WritableRaster outRaster) {
if (outRaster == null) {
return (WritableRaster) getData();
}
int width = outRaster.getWidth();
int height = outRaster.getHeight();
int startX = outRaster.getMinX();
int startY = outRaster.getMinY();
Object tdata = null;
for (int i = startY; i < startY+height; i++) {
tdata = raster.getDataElements(startX,i,width,1,tdata);
outRaster.setDataElements(startX,i,width,1, tdata);
}
return outRaster;
}
/**
* Sets a rectangular region of the image to the contents of the
* specified <code>Raster</code> <code>r</code>, which is
* assumed to be in the same coordinate space as the
* <code>BufferedImage</code>. The operation is clipped to the bounds
* of the <code>BufferedImage</code>.
* @param r the specified <code>Raster</code>
* @see #getData
* @see #getData(Rectangle)
*/
public void setData(Raster r) {
int width = r.getWidth();
int height = r.getHeight();
int startX = r.getMinX();
int startY = r.getMinY();
int[] tdata = null;
// Clip to the current Raster
Rectangle rclip = new Rectangle(startX, startY, width, height);
Rectangle bclip = new Rectangle(0, 0, raster.width, raster.height);
Rectangle intersect = rclip.intersection(bclip);
if (intersect.isEmpty()) {
return;
}
width = intersect.width;
height = intersect.height;
startX = intersect.x;
startY = intersect.y;
// remind use get/setDataElements for speed if Rasters are
// compatible
for (int i = startY; i < startY+height; i++) {
tdata = r.getPixels(startX,i,width,1,tdata);
raster.setPixels(startX,i,width,1, tdata);
}
}
/**
* Adds a tile observer. If the observer is already present,
* it receives multiple notifications.
* @param to the specified {@link TileObserver}
*/
public void addTileObserver (TileObserver to) {
}
/**
* Removes a tile observer. If the observer was not registered,
* nothing happens. If the observer was registered for multiple
* notifications, it is now registered for one fewer notification.
* @param to the specified <code>TileObserver</code>.
*/
public void removeTileObserver (TileObserver to) {
}
/**
* Returns whether or not a tile is currently checked out for writing.
* @param tileX the x index of the tile.
* @param tileY the y index of the tile.
* @return <code>true</code> if the tile specified by the specified
* indices is checked out for writing; <code>false</code>
* otherwise.
* @exception ArrayIndexOutOfBoundsException if both
* <code>tileX</code> and <code>tileY</code> are not equal
* to 0
*/
public boolean isTileWritable (int tileX, int tileY) {
if (tileX == 0 && tileY == 0) {
return true;
}
throw new IllegalArgumentException("Only 1 tile in image");
}
/**
* Returns an array of {@link Point} objects indicating which tiles
* are checked out for writing. Returns <code>null</code> if none are
* checked out.
* @return a <code>Point</code> array that indicates the tiles that
* are checked out for writing, or <code>null</code> if no
* tiles are checked out for writing.
*/
public Point[] getWritableTileIndices() {
Point[] p = new Point[1];
p[0] = new Point(0, 0);
return p;
}
/**
* Returns whether or not any tile is checked out for writing.
* Semantically equivalent to
* <pre>
* (getWritableTileIndices() != null).
* </pre>
* @return <code>true</code> if any tile is checked out for writing;
* <code>false</code> otherwise.
*/
public boolean hasTileWriters () {
return true;
}
/**
* Checks out a tile for writing. All registered
* <code>TileObservers</code> are notified when a tile goes from having
* no writers to having one writer.
* @param tileX the x index of the tile
* @param tileY the y index of the tile
* @return a <code>WritableRaster</code> that is the tile, indicated by
* the specified indices, to be checked out for writing.
*/
public WritableRaster getWritableTile (int tileX, int tileY) {
return raster;
}
/**
* Relinquishes permission to write to a tile. If the caller
* continues to write to the tile, the results are undefined.
* Calls to this method should only appear in matching pairs
* with calls to {@link #getWritableTile(int, int) getWritableTile(int, int)}. Any other leads
* to undefined results. All registered <code>TileObservers</code>
* are notified when a tile goes from having one writer to having no
* writers.
* @param tileX the x index of the tile
* @param tileY the y index of the tile
*/
public void releaseWritableTile (int tileX, int tileY) {
}
/**
* Returns the transparency. Returns either OPAQUE, BITMASK,
* or TRANSLUCENT.
* @return the transparency of this <code>BufferedImage</code>.
* @see Transparency#OPAQUE
* @see Transparency#BITMASK
* @see Transparency#TRANSLUCENT
* @since 1.5
*/
public int getTransparency() {
return colorModel.getTransparency();
}
}