/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Igor V. Stolyarov
* @version $Revision$
*/
package java.awt.image;
import com.android.internal.awt.AndroidGraphics2D;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Transparency;
import java.awt.color.ColorSpace;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
import org.apache.harmony.awt.gl.ImageSurface;
import org.apache.harmony.awt.gl.Surface;
import org.apache.harmony.awt.gl.image.BufferedImageSource;
import org.apache.harmony.awt.internal.nls.Messages;
/**
* The BufferedImage class describes an Image which contains a buffer of image
* data and includes a ColorModel and a Raster for this data. This class
* provides methods for obtaining and setting the Raster and for manipulating
* the ColorModel parameters.
*
* @since Android 1.0
*/
public class BufferedImage extends Image implements WritableRenderedImage, Transparency {
/**
* The Constant TYPE_CUSTOM indicates that Image type is unknown.
*/
public static final int TYPE_CUSTOM = 0;
/**
* The Constant TYPE_INT_RGB indicates an image with 8 bit RGB color
* components, it has a DirectColorModel without alpha.
*/
public static final int TYPE_INT_RGB = 1;
/**
* The Constant TYPE_INT_ARGB indicates an image with 8 bit RGBA color
* components, it has a DirectColorModel with alpha.
*/
public static final int TYPE_INT_ARGB = 2;
/**
* The Constant TYPE_INT_ARGB_PRE indicates an image with 8 bit RGBA color
* components, it has a DirectColorModel with alpha, and image data is
* pre-multiplied by alpha.
*/
public static final int TYPE_INT_ARGB_PRE = 3;
/**
* The Constant TYPE_INT_BGR indicates an image with 8 bit RGB color
* components, BGR color model (with the colors Blue, Green, and Red). There
* is no alpha. The image has a DirectColorModel.
*/
public static final int TYPE_INT_BGR = 4;
/**
* The Constant TYPE_3BYTE_BGR indicates an image with 8 bit RGB color
* components, BGR color model (with the colors Blue, Green, and Red stored
* in 3 bytes). There is no alpha. The image has a ComponentColorModel.
*/
public static final int TYPE_3BYTE_BGR = 5;
/**
* The Constant TYPE_4BYTE_ABGR indicates an image with 8 bit RGBA color
* components stored in 3 bytes and 1 byte of alpha. It has a
* ComponentColorModel with alpha.
*/
public static final int TYPE_4BYTE_ABGR = 6;
/**
* The Constant TYPE_4BYTE_ABGR_PRE indicates an image with 8 bit RGBA color
* components stored in 3 bytes and 1 byte for alpha. The image has a
* ComponentColorModel with alpha. The color data is pre-multiplied with
* alpha.
*/
public static final int TYPE_4BYTE_ABGR_PRE = 7;
/**
* The Constant TYPE_USHORT_565_RGB indicates an image with 565 RGB color
* components (5-bits red, 6-bits green, 5-bits blue) with no alpha. This
* image has a DirectColorModel.
*/
public static final int TYPE_USHORT_565_RGB = 8;
/**
* The Constant TYPE_USHORT_555_RGB indicates an image with 555 RGB color
* components (5-bits red, 5-bits green, 5-bits blue) with no alpha. This
* image has a DirectColorModel.
*/
public static final int TYPE_USHORT_555_RGB = 9;
/**
* The Constant TYPE_BYTE_GRAY indicates a unsigned byte image. This image
* has a ComponentColorModel with a CS_GRAY ColorSpace.
*/
public static final int TYPE_BYTE_GRAY = 10;
/**
* The Constant TYPE_USHORT_GRAY indicates an unsigned short image. This
* image has a ComponentColorModel with a CS_GRAY ColorSpace.
*/
public static final int TYPE_USHORT_GRAY = 11;
/**
* The Constant TYPE_BYTE_BINARY indicates an opaque byte-packed 1, 2 or 4
* bit image. The image has an IndexColorModel without alpha.
*/
public static final int TYPE_BYTE_BINARY = 12;
/**
* The Constant TYPE_BYTE_INDEXED indicates an indexed byte image.
*/
public static final int TYPE_BYTE_INDEXED = 13;
/**
* The Constant ALPHA_MASK.
*/
private static final int ALPHA_MASK = 0xff000000;
/**
* The Constant RED_MASK.
*/
private static final int RED_MASK = 0x00ff0000;
/**
* The Constant GREEN_MASK.
*/
private static final int GREEN_MASK = 0x0000ff00;
/**
* The Constant BLUE_MASK.
*/
private static final int BLUE_MASK = 0x000000ff;
/**
* The Constant RED_BGR_MASK.
*/
private static final int RED_BGR_MASK = 0x000000ff;
/**
* The Constant GREEN_BGR_MASK.
*/
private static final int GREEN_BGR_MASK = 0x0000ff00;
/**
* The Constant BLUE_BGR_MASK.
*/
private static final int BLUE_BGR_MASK = 0x00ff0000;
/**
* The Constant RED_565_MASK.
*/
private static final int RED_565_MASK = 0xf800;
/**
* The Constant GREEN_565_MASK.
*/
private static final int GREEN_565_MASK = 0x07e0;
/**
* The Constant BLUE_565_MASK.
*/
private static final int BLUE_565_MASK = 0x001f;
/**
* The Constant RED_555_MASK.
*/
private static final int RED_555_MASK = 0x7c00;
/**
* The Constant GREEN_555_MASK.
*/
private static final int GREEN_555_MASK = 0x03e0;
/**
* The Constant BLUE_555_MASK.
*/
private static final int BLUE_555_MASK = 0x001f;
/**
* The cm.
*/
private ColorModel cm;
/**
* The raster.
*/
private final WritableRaster raster;
/**
* The image type.
*/
private final int imageType;
/**
* The properties.
*/
private Hashtable<?, ?> properties;
// Surface of the Buffered Image - used for blitting one Buffered Image
// on the other one or on the Component
/**
* The image surf.
*/
private final ImageSurface imageSurf;
/**
* Instantiates a new BufferedImage with the specified ColorModel, and
* WritableRaster objects. The Raster data can be be divided or multiplied
* by alpha. It depends on the alphaPremultiplied state in the ColorModel.
*
* @param cm
* the ColorModel of the new image.
* @param raster
* the WritableRaster of the new image.
* @param isRasterPremultiplied
* if true the data of the specified Raster is pre-multiplied by
* alpha.
* @param properties
* the properties of new Image.
*/
public BufferedImage(ColorModel cm, WritableRaster raster, boolean isRasterPremultiplied,
Hashtable<?, ?> properties) {
if (!cm.isCompatibleRaster(raster)) {
// awt.4D=The raster is incompatible with this ColorModel
throw new IllegalArgumentException(Messages.getString("awt.4D")); //$NON-NLS-1$
}
if (raster.getMinX() != 0 || raster.getMinY() != 0) {
// awt.228=minX or minY of this raster not equal to zero
throw new IllegalArgumentException(Messages.getString("awt.228")); //$NON-NLS-1$
}
this.cm = cm;
this.raster = raster;
this.properties = properties;
coerceData(isRasterPremultiplied);
imageType = Surface.getType(cm, raster);
imageSurf = createImageSurface(imageType);
}
/**
* Instantiates a new BufferedImage with the specified width, height
* predefined image type (TYPE_BYTE_BINARY or TYPE_BYTE_INDEXED) and the
* specified IndexColorModel.
*
* @param width
* the width of new image.
* @param height
* the height of new image.
* @param imageType
* the predefined image type.
* @param cm
* the specified IndexColorModel.
*/
public BufferedImage(int width, int height, int imageType, IndexColorModel cm) {
switch (imageType) {
case TYPE_BYTE_BINARY:
if (cm.hasAlpha()) {
// awt.227=This image type can't have alpha
throw new IllegalArgumentException(Messages.getString("awt.227")); //$NON-NLS-1$
}
int pixel_bits = 0;
int mapSize = cm.getMapSize();
if (mapSize <= 2) {
pixel_bits = 1;
} else if (mapSize <= 4) {
pixel_bits = 2;
} else if (mapSize <= 16) {
pixel_bits = 4;
} else {
// awt.221=The imageType is TYPE_BYTE_BINARY and the color
// map has more than 16 entries
throw new IllegalArgumentException(Messages.getString("awt.221")); //$NON-NLS-1$
}
raster = Raster.createPackedRaster(DataBuffer.TYPE_BYTE, width, height, 1,
pixel_bits, null);
break;
case TYPE_BYTE_INDEXED:
raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, height, 1,
null);
break;
default:
// awt.222=The imageType is not TYPE_BYTE_BINARY or
// TYPE_BYTE_INDEXED
throw new IllegalArgumentException(Messages.getString("awt.222")); //$NON-NLS-1$
}
if (!cm.isCompatibleRaster(raster)) {
// awt.223=The imageType is not compatible with ColorModel
throw new IllegalArgumentException(Messages.getString("awt.223")); //$NON-NLS-1$
}
this.cm = cm;
this.imageType = imageType;
imageSurf = createImageSurface(imageType);
}
/**
* Instantiates a new BufferedImage with the specified width, height and
* predefined image type.
*
* @param width
* the width of new image.
* @param height
* the height of new image.
* @param imageType
* the predefined image type.
*/
public BufferedImage(int width, int height, int imageType) {
switch (imageType) {
case TYPE_INT_RGB:
cm = new DirectColorModel(24, RED_MASK, GREEN_MASK, BLUE_MASK);
raster = cm.createCompatibleWritableRaster(width, height);
break;
case TYPE_INT_ARGB:
cm = ColorModel.getRGBdefault();
raster = cm.createCompatibleWritableRaster(width, height);
break;
case TYPE_INT_ARGB_PRE:
cm = new DirectColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), 32, RED_MASK,
GREEN_MASK, BLUE_MASK, ALPHA_MASK, true, DataBuffer.TYPE_INT);
raster = cm.createCompatibleWritableRaster(width, height);
break;
case TYPE_INT_BGR:
cm = new DirectColorModel(24, RED_BGR_MASK, GREEN_BGR_MASK, BLUE_BGR_MASK);
raster = cm.createCompatibleWritableRaster(width, height);
break;
case TYPE_3BYTE_BGR: {
int bits[] = {
8, 8, 8
};
int bandOffsets[] = {
2, 1, 0
};
cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), bits,
false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);
raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, height,
width * 3, 3, bandOffsets, null);
}
break;
case TYPE_4BYTE_ABGR: {
int bits[] = {
8, 8, 8, 8
};
int bandOffsets[] = {
3, 2, 1, 0
};
cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), bits,
true, false, Transparency.TRANSLUCENT, DataBuffer.TYPE_BYTE);
raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, height,
width * 4, 4, bandOffsets, null);
}
break;
case TYPE_4BYTE_ABGR_PRE: {
int bits[] = {
8, 8, 8, 8
};
int bandOffsets[] = {
3, 2, 1, 0
};
cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), bits,
true, true, Transparency.TRANSLUCENT, DataBuffer.TYPE_BYTE);
raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, height,
width * 4, 4, bandOffsets, null);
}
break;
case TYPE_USHORT_565_RGB:
cm = new DirectColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), 16,
RED_565_MASK, GREEN_565_MASK, BLUE_565_MASK, 0, false,
DataBuffer.TYPE_USHORT);
raster = cm.createCompatibleWritableRaster(width, height);
break;
case TYPE_USHORT_555_RGB:
cm = new DirectColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), 15,
RED_555_MASK, GREEN_555_MASK, BLUE_555_MASK, 0, false,
DataBuffer.TYPE_USHORT);
raster = cm.createCompatibleWritableRaster(width, height);
break;
case TYPE_BYTE_GRAY: {
int bits[] = {
8
};
cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_GRAY), bits,
false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);
raster = cm.createCompatibleWritableRaster(width, height);
}
break;
case TYPE_USHORT_GRAY: {
int bits[] = {
16
};
cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_GRAY), bits,
false, false, Transparency.OPAQUE, DataBuffer.TYPE_USHORT);
raster = cm.createCompatibleWritableRaster(width, height);
}
break;
case TYPE_BYTE_BINARY: {
int colorMap[] = {
0, 0xffffff
};
cm = new IndexColorModel(1, 2, colorMap, 0, false, -1, DataBuffer.TYPE_BYTE);
raster = Raster.createPackedRaster(DataBuffer.TYPE_BYTE, width, height, 1, 1, null);
}
break;
case TYPE_BYTE_INDEXED: {
int colorMap[] = 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) {
colorMap[i] = (r << 16) | (g << 8) | b;
i++;
}
}
}
int gray = 0x12;
for (; i < 256; i++, gray += 6) {
colorMap[i] = (gray << 16) | (gray << 8) | gray;
}
cm = new IndexColorModel(8, 256, colorMap, 0, false, -1, DataBuffer.TYPE_BYTE);
raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, width, height, 1,
null);
}
break;
default:
// awt.224=Unknown image type
throw new IllegalArgumentException(Messages.getString("awt.224")); //$NON-NLS-1$
}
this.imageType = imageType;
imageSurf = createImageSurface(imageType);
}
@Override
public Object getProperty(String name, ImageObserver observer) {
return getProperty(name);
}
public Object getProperty(String name) {
if (name == null) {
// awt.225=Property name is null
throw new NullPointerException(Messages.getString("awt.225")); //$NON-NLS-1$
}
if (properties == null) {
return Image.UndefinedProperty;
}
Object property = properties.get(name);
if (property == null) {
property = Image.UndefinedProperty;
}
return property;
}
public WritableRaster copyData(WritableRaster outRaster) {
if (outRaster == null) {
outRaster = Raster.createWritableRaster(raster.getSampleModel(), new Point(raster
.getSampleModelTranslateX(), raster.getSampleModelTranslateY()));
}
int w = outRaster.getWidth();
int h = outRaster.getHeight();
int minX = outRaster.getMinX();
int minY = outRaster.getMinY();
Object data = null;
data = raster.getDataElements(minX, minY, w, h, data);
outRaster.setDataElements(minX, minY, w, h, data);
return outRaster;
}
public Raster getData(Rectangle rect) {
int minX = rect.x;
int minY = rect.y;
int w = rect.width;
int h = rect.height;
SampleModel sm = raster.getSampleModel();
SampleModel nsm = sm.createCompatibleSampleModel(w, h);
WritableRaster outr = Raster.createWritableRaster(nsm, rect.getLocation());
Object data = null;
data = raster.getDataElements(minX, minY, w, h, data);
outr.setDataElements(minX, minY, w, h, data);
return outr;
}
public Vector<RenderedImage> getSources() {
return null;
}
public String[] getPropertyNames() {
if (properties == null) {
return null;
}
Vector<String> v = new Vector<String>();
for (Enumeration<?> e = properties.keys(); e.hasMoreElements();) {
try {
v.add((String)e.nextElement());
} catch (ClassCastException ex) {
}
}
int size = v.size();
if (size > 0) {
String names[] = new String[size];
for (int i = 0; i < size; i++) {
names[i] = v.elementAt(i);
}
return names;
}
return null;
}
/**
* Returns the string representation of this BufferedImage object.
*
* @return the string representation of this BufferedImage object.
*/
@Override
public String toString() {
return "BufferedImage@" + Integer.toHexString(hashCode()) + //$NON-NLS-1$
": type = " + imageType + " " + cm + " " + raster; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
public WritableRaster getWritableTile(int tileX, int tileY) {
return raster;
}
/**
* Gets the WritableRaster of this BufferedImage.
*
* @return the WritableRaster of this BufferedImage.
*/
public WritableRaster getRaster() {
return raster;
}
/**
* Gets a WritableRaster object which contains the alpha channel of
* BufferedImage object with ColorModel objects that supports a separate
* alpha channel such as ComponentColorModel or DirectColorModel.
*
* @return the WritableRaster object which contains the alpha channel of
* this BufferedImage.
*/
public WritableRaster getAlphaRaster() {
return cm.getAlphaRaster(raster);
}
public void removeTileObserver(TileObserver to) {
}
public void addTileObserver(TileObserver to) {
}
public SampleModel getSampleModel() {
return raster.getSampleModel();
}
public void setData(Raster r) {
Rectangle from = r.getBounds();
Rectangle to = raster.getBounds();
Rectangle intersection = to.intersection(from);
int minX = intersection.x;
int minY = intersection.y;
int w = intersection.width;
int h = intersection.height;
Object data = null;
data = r.getDataElements(minX, minY, w, h, data);
raster.setDataElements(minX, minY, w, h, data);
}
public Raster getTile(int tileX, int tileY) {
if (tileX == 0 && tileY == 0) {
return raster;
}
// awt.226=Both tileX and tileY are not equal to 0
throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.226")); //$NON-NLS-1$
}
public Raster getData() {
int w = raster.getWidth();
int h = raster.getHeight();
int minX = raster.getMinX();
int minY = raster.getMinY();
WritableRaster outr = Raster.createWritableRaster(raster.getSampleModel(), new Point(raster
.getSampleModelTranslateX(), raster.getSampleModelTranslateY()));
Object data = null;
data = raster.getDataElements(minX, minY, w, h, data);
outr.setDataElements(minX, minY, w, h, data);
return outr;
}
@Override
public ImageProducer getSource() {
return new BufferedImageSource(this, properties);
}
@Override
public int getWidth(ImageObserver observer) {
return raster.getWidth();
}
@Override
public int getHeight(ImageObserver observer) {
return raster.getHeight();
}
public ColorModel getColorModel() {
return cm;
}
/**
* Gets the rectangular area of this BufferedImage as a subimage.
*
* @param x
* the x coordinate.
* @param y
* the y coordinate.
* @param w
* the width of the subimage.
* @param h
* the height of the subimage.
* @return the BufferedImage.
*/
public BufferedImage getSubimage(int x, int y, int w, int h) {
WritableRaster wr = raster.createWritableChild(x, y, w, h, 0, 0, null);
return new BufferedImage(cm, wr, cm.isAlphaPremultiplied(), properties);
}
public Point[] getWritableTileIndices() {
Point points[] = new Point[1];
points[0] = new Point(0, 0);
return points;
}
/**
* Creates the Graphics2D object which allows to draw into this
* BufferedImage.
*
* @return the graphics2D object.
*/
public Graphics2D createGraphics() {
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
// return ge.createGraphics(this);
// ???AWT hack, FIXME
// return AndroidGraphics2D.getInstance();
// throw new RuntimeException("Not implemented!");
return null;
}
@Override
public Graphics getGraphics() {
return createGraphics();
}
/**
* Coerces the data to achieve the state which is specified by the
* isAlphaPremultiplied variable.
*
* @param isAlphaPremultiplied
* the is alpha pre-multiplied state.
*/
public void coerceData(boolean isAlphaPremultiplied) {
if (cm.hasAlpha() && cm.isAlphaPremultiplied() != isAlphaPremultiplied) {
cm = cm.coerceData(raster, isAlphaPremultiplied);
}
}
/**
* Gets an array of colors in the TYPE_INT_ARGB color model and default sRGB
* color space of the specified area of this BufferedImage. The result array
* is composed by the following algorithm:
* <p>
* pixel = rgbArray[offset + (y-startY)*scansize + (x-startX)]
* </p>
*
* @param startX
* the start X area coordinate.
* @param startY
* the start Y area coordinate.
* @param w
* the width of the area.
* @param h
* the height of the area.
* @param rgbArray
* the result array will be stored to this array.
* @param offset
* the offset of the rgbArray array.
* @param scansize
* the scanline stride for the rgbArray.
* @return an array of colors for the specified area.
*/
public int[] getRGB(int startX, int startY, int w, int h, int[] rgbArray, int offset,
int scansize) {
if (rgbArray == null) {
rgbArray = new int[offset + h * scansize];
}
int off = offset;
for (int y = startY; y < startY + h; y++, off += scansize) {
int i = off;
for (int x = startX; x < startX + w; x++, i++) {
rgbArray[i] = cm.getRGB(raster.getDataElements(x, y, null));
}
}
return rgbArray;
}
/**
* Sets RGB values from the specified array to the specified BufferedImage
* area. The pixels are in the default RGB color model (TYPE_INT_ARGB) and
* default sRGB color space.
*
* @param startX
* the start X coordinate.
* @param startY
* the start Y coordinate.
* @param w
* the width of the BufferedImage area.
* @param h
* the height of the BufferedImage area.
* @param rgbArray
* the array of RGB values.
* @param offset
* the offset of the rgbArray array.
* @param scansize
* the scanline stride for the rgbArray.
*/
public void setRGB(int startX, int startY, int w, int h, int[] rgbArray, int offset,
int scansize) {
int off = offset;
for (int y = startY; y < startY + h; y++, off += scansize) {
int i = off;
for (int x = startX; x < startX + w; x++, i++) {
raster.setDataElements(x, y, cm.getDataElements(rgbArray[i], null));
}
}
}
/**
* Sets a the specified RGB value to the specified pixel of this
* BufferedImage. The pixel should be in the default RGB color model
* (TYPE_INT_ARGB) and default sRGB color space.
*
* @param x
* the X coordinate of the pixel.
* @param y
* the Y coordinate of the pixel.
* @param rgb
* the RGB value to be set.
*/
public synchronized void setRGB(int x, int y, int rgb) {
raster.setDataElements(x, y, cm.getDataElements(rgb, null));
}
public boolean isTileWritable(int tileX, int tileY) {
if (tileX == 0 && tileY == 0) {
return true;
}
// awt.226=Both tileX and tileY are not equal to 0
throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.226")); //$NON-NLS-1$
}
public void releaseWritableTile(int tileX, int tileY) {
}
/**
* Gets a color in the TYPE_INT_ARGB color model and default sRGB color
* space of the specified pixel.
*
* @param x
* the X coordinate of the pixel.
* @param y
* the Y coordinate of the pixel.
* @return the color of the specified pixel in the TYPE_INT_ARGB color model
* and default sRGB color space.
*/
public int getRGB(int x, int y) {
return cm.getRGB(raster.getDataElements(x, y, null));
}
/**
* Returns true if alpha is pre-multiplied, false if alpha is not
* pre-multiplied or there is no alpha.
*
* @return true if alpha is pre-multiplied, false if alpha is not
* pre-multiplied or there is no alpha.
*/
public boolean isAlphaPremultiplied() {
return cm.isAlphaPremultiplied();
}
public boolean hasTileWriters() {
return true;
}
@Override
public void flush() {
imageSurf.dispose();
}
public int getWidth() {
return raster.getWidth();
}
/**
* Gets the image type.
*
* @return the image type.
*/
public int getType() {
return imageType;
}
public int getTileWidth() {
return raster.getWidth();
}
public int getTileHeight() {
return raster.getHeight();
}
public int getTileGridYOffset() {
return raster.getSampleModelTranslateY();
}
public int getTileGridXOffset() {
return raster.getSampleModelTranslateX();
}
public int getNumYTiles() {
return 1;
}
public int getNumXTiles() {
return 1;
}
public int getMinY() {
return raster.getMinY();
}
public int getMinX() {
return raster.getMinX();
}
public int getMinTileY() {
return 0;
}
public int getMinTileX() {
return 0;
}
public int getHeight() {
return raster.getHeight();
}
/**
* Creates the image surface.
*
* @param type
* the type.
* @return the image surface.
*/
private ImageSurface createImageSurface(int type) {
return new ImageSurface(getColorModel(), getRaster(), type);
}
/**
* Gets the image surface.
*
* @return the image surface.
*/
ImageSurface getImageSurface() {
return imageSurf;
}
public int getTransparency() {
return cm.getTransparency();
}
}
|
