/*
* Copyright (c) 1997, 2013, 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.geom.AffineTransform;
import java.awt.geom.NoninvertibleTransformException;
import java.awt.geom.Rectangle2D;
import java.awt.geom.Point2D;
import java.awt.AlphaComposite;
import java.awt.GraphicsEnvironment;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Transparency;
import java.lang.annotation.Native;
import sun.awt.image.ImagingLib;
This class uses an affine transform to perform a linear mapping from
2D coordinates in the source image or Raster
to 2D coordinates
in the destination image or Raster
.
The type of interpolation that is used is specified through a constructor,
either by a RenderingHints
object or by one of the integer
interpolation types defined in this class.
If a RenderingHints
object is specified in the constructor, the
interpolation hint and the rendering quality hint are used to set
the interpolation type for this operation. The color rendering hint
and the dithering hint can be used when color conversion is required.
Note that the following constraints have to be met:
- The source and destination must be different.
- For
Raster
objects, the number of bands in the source must
be equal to the number of bands in the destination.
See Also:
/**
* This class uses an affine transform to perform a linear mapping from
* 2D coordinates in the source image or <CODE>Raster</CODE> to 2D coordinates
* in the destination image or <CODE>Raster</CODE>.
* The type of interpolation that is used is specified through a constructor,
* either by a <CODE>RenderingHints</CODE> object or by one of the integer
* interpolation types defined in this class.
* <p>
* If a <CODE>RenderingHints</CODE> object is specified in the constructor, the
* interpolation hint and the rendering quality hint are used to set
* the interpolation type for this operation. The color rendering hint
* and the dithering hint can be used when color conversion is required.
* <p>
* Note that the following constraints have to be met:
* <ul>
* <li>The source and destination must be different.
* <li>For <CODE>Raster</CODE> objects, the number of bands in the source must
* be equal to the number of bands in the destination.
* </ul>
* @see AffineTransform
* @see BufferedImageFilter
* @see java.awt.RenderingHints#KEY_INTERPOLATION
* @see java.awt.RenderingHints#KEY_RENDERING
* @see java.awt.RenderingHints#KEY_COLOR_RENDERING
* @see java.awt.RenderingHints#KEY_DITHERING
*/
public class AffineTransformOp implements BufferedImageOp, RasterOp {
private AffineTransform xform;
RenderingHints hints;
Nearest-neighbor interpolation type.
/**
* Nearest-neighbor interpolation type.
*/
@Native public static final int TYPE_NEAREST_NEIGHBOR = 1;
Bilinear interpolation type.
/**
* Bilinear interpolation type.
*/
@Native public static final int TYPE_BILINEAR = 2;
Bicubic interpolation type.
/**
* Bicubic interpolation type.
*/
@Native public static final int TYPE_BICUBIC = 3;
int interpolationType = TYPE_NEAREST_NEIGHBOR;
Constructs an AffineTransformOp
given an affine transform.
The interpolation type is determined from the
RenderingHints
object. If the interpolation hint is
defined, it will be used. Otherwise, if the rendering quality hint is
defined, the interpolation type is determined from its value. If no
hints are specified (hints
is null), the interpolation type is
TYPE_NEAREST_NEIGHBOR
. Params: - xform – The
AffineTransform
to use for the
operation. - hints – The
RenderingHints
object used to specify
the interpolation type for the operation.
Throws: - ImagingOpException – if the transform is non-invertible.
See Also:
/**
* Constructs an <CODE>AffineTransformOp</CODE> given an affine transform.
* The interpolation type is determined from the
* <CODE>RenderingHints</CODE> object. If the interpolation hint is
* defined, it will be used. Otherwise, if the rendering quality hint is
* defined, the interpolation type is determined from its value. If no
* hints are specified (<CODE>hints</CODE> is null),
* the interpolation type is {@link #TYPE_NEAREST_NEIGHBOR
* TYPE_NEAREST_NEIGHBOR}.
*
* @param xform The <CODE>AffineTransform</CODE> to use for the
* operation.
*
* @param hints The <CODE>RenderingHints</CODE> object used to specify
* the interpolation type for the operation.
*
* @throws ImagingOpException if the transform is non-invertible.
* @see java.awt.RenderingHints#KEY_INTERPOLATION
* @see java.awt.RenderingHints#KEY_RENDERING
*/
public AffineTransformOp(AffineTransform xform, RenderingHints hints){
validateTransform(xform);
this.xform = (AffineTransform) xform.clone();
this.hints = hints;
if (hints != null) {
Object value = hints.get(hints.KEY_INTERPOLATION);
if (value == null) {
value = hints.get(hints.KEY_RENDERING);
if (value == hints.VALUE_RENDER_SPEED) {
interpolationType = TYPE_NEAREST_NEIGHBOR;
}
else if (value == hints.VALUE_RENDER_QUALITY) {
interpolationType = TYPE_BILINEAR;
}
}
else if (value == hints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR) {
interpolationType = TYPE_NEAREST_NEIGHBOR;
}
else if (value == hints.VALUE_INTERPOLATION_BILINEAR) {
interpolationType = TYPE_BILINEAR;
}
else if (value == hints.VALUE_INTERPOLATION_BICUBIC) {
interpolationType = TYPE_BICUBIC;
}
}
else {
interpolationType = TYPE_NEAREST_NEIGHBOR;
}
}
Constructs an AffineTransformOp
given an affine transform
and the interpolation type.
Params: - xform – The
AffineTransform
to use for the operation. - interpolationType – One of the integer interpolation type constants defined by this class:
TYPE_NEAREST_NEIGHBOR
, TYPE_BILINEAR
, TYPE_BICUBIC
.
Throws: - ImagingOpException – if the transform is non-invertible.
/**
* Constructs an <CODE>AffineTransformOp</CODE> given an affine transform
* and the interpolation type.
*
* @param xform The <CODE>AffineTransform</CODE> to use for the operation.
* @param interpolationType One of the integer
* interpolation type constants defined by this class:
* {@link #TYPE_NEAREST_NEIGHBOR TYPE_NEAREST_NEIGHBOR},
* {@link #TYPE_BILINEAR TYPE_BILINEAR},
* {@link #TYPE_BICUBIC TYPE_BICUBIC}.
* @throws ImagingOpException if the transform is non-invertible.
*/
public AffineTransformOp(AffineTransform xform, int interpolationType) {
validateTransform(xform);
this.xform = (AffineTransform)xform.clone();
switch(interpolationType) {
case TYPE_NEAREST_NEIGHBOR:
case TYPE_BILINEAR:
case TYPE_BICUBIC:
break;
default:
throw new IllegalArgumentException("Unknown interpolation type: "+
interpolationType);
}
this.interpolationType = interpolationType;
}
Returns the interpolation type used by this op.
See Also: Returns: the interpolation type.
/**
* Returns the interpolation type used by this op.
* @return the interpolation type.
* @see #TYPE_NEAREST_NEIGHBOR
* @see #TYPE_BILINEAR
* @see #TYPE_BICUBIC
*/
public final int getInterpolationType() {
return interpolationType;
}
Transforms the source BufferedImage
and stores the results
in the destination BufferedImage
.
If the color models for the two images do not match, a color
conversion into the destination color model is performed.
If the destination image is null,
a BufferedImage
is created with the source
ColorModel
.
The coordinates of the rectangle returned by
getBounds2D(BufferedImage)
are not necessarily the same as the coordinates of the
BufferedImage
returned by this method. If the
upper-left corner coordinates of the rectangle are
negative then this part of the rectangle is not drawn. If the
upper-left corner coordinates of the rectangle are positive
then the filtered image is drawn at that position in the
destination BufferedImage
.
An IllegalArgumentException
is thrown if the source is
the same as the destination.
Params: - src – The
BufferedImage
to transform. - dst – The
BufferedImage
in which to store the results
of the transformation.
Throws: - IllegalArgumentException – if
src
and
dst
are the same - ImagingOpException – if the image cannot be transformed
because of a data-processing error that might be
caused by an invalid image format, tile format, or
image-processing operation, or any other unsupported
operation.
Returns: The filtered BufferedImage
.
/**
* Transforms the source <CODE>BufferedImage</CODE> and stores the results
* in the destination <CODE>BufferedImage</CODE>.
* If the color models for the two images do not match, a color
* conversion into the destination color model is performed.
* If the destination image is null,
* a <CODE>BufferedImage</CODE> is created with the source
* <CODE>ColorModel</CODE>.
* <p>
* The coordinates of the rectangle returned by
* <code>getBounds2D(BufferedImage)</code>
* are not necessarily the same as the coordinates of the
* <code>BufferedImage</code> returned by this method. If the
* upper-left corner coordinates of the rectangle are
* negative then this part of the rectangle is not drawn. If the
* upper-left corner coordinates of the rectangle are positive
* then the filtered image is drawn at that position in the
* destination <code>BufferedImage</code>.
* <p>
* An <CODE>IllegalArgumentException</CODE> is thrown if the source is
* the same as the destination.
*
* @param src The <CODE>BufferedImage</CODE> to transform.
* @param dst The <CODE>BufferedImage</CODE> in which to store the results
* of the transformation.
*
* @return The filtered <CODE>BufferedImage</CODE>.
* @throws IllegalArgumentException if <code>src</code> and
* <code>dst</code> are the same
* @throws ImagingOpException if the image cannot be transformed
* because of a data-processing error that might be
* caused by an invalid image format, tile format, or
* image-processing operation, or any other unsupported
* operation.
*/
public final BufferedImage filter(BufferedImage src, BufferedImage dst) {
if (src == null) {
throw new NullPointerException("src image is null");
}
if (src == dst) {
throw new IllegalArgumentException("src image cannot be the "+
"same as the dst image");
}
boolean needToConvert = false;
ColorModel srcCM = src.getColorModel();
ColorModel dstCM;
BufferedImage origDst = dst;
if (dst == null) {
dst = createCompatibleDestImage(src, null);
dstCM = srcCM;
origDst = dst;
}
else {
dstCM = dst.getColorModel();
if (srcCM.getColorSpace().getType() !=
dstCM.getColorSpace().getType())
{
int type = xform.getType();
boolean needTrans = ((type&
(xform.TYPE_MASK_ROTATION|
xform.TYPE_GENERAL_TRANSFORM))
!= 0);
if (! needTrans && type != xform.TYPE_TRANSLATION && type != xform.TYPE_IDENTITY)
{
double[] mtx = new double[4];
xform.getMatrix(mtx);
// Check out the matrix. A non-integral scale will force ARGB
// since the edge conditions can't be guaranteed.
needTrans = (mtx[0] != (int)mtx[0] || mtx[3] != (int)mtx[3]);
}
if (needTrans &&
srcCM.getTransparency() == Transparency.OPAQUE)
{
// Need to convert first
ColorConvertOp ccop = new ColorConvertOp(hints);
BufferedImage tmpSrc = null;
int sw = src.getWidth();
int sh = src.getHeight();
if (dstCM.getTransparency() == Transparency.OPAQUE) {
tmpSrc = new BufferedImage(sw, sh,
BufferedImage.TYPE_INT_ARGB);
}
else {
WritableRaster r =
dstCM.createCompatibleWritableRaster(sw, sh);
tmpSrc = new BufferedImage(dstCM, r,
dstCM.isAlphaPremultiplied(),
null);
}
src = ccop.filter(src, tmpSrc);
}
else {
needToConvert = true;
dst = createCompatibleDestImage(src, null);
}
}
}
if (interpolationType != TYPE_NEAREST_NEIGHBOR &&
dst.getColorModel() instanceof IndexColorModel) {
dst = new BufferedImage(dst.getWidth(), dst.getHeight(),
BufferedImage.TYPE_INT_ARGB);
}
if (ImagingLib.filter(this, src, dst) == null) {
throw new ImagingOpException ("Unable to transform src image");
}
if (needToConvert) {
ColorConvertOp ccop = new ColorConvertOp(hints);
ccop.filter(dst, origDst);
}
else if (origDst != dst) {
java.awt.Graphics2D g = origDst.createGraphics();
try {
g.setComposite(AlphaComposite.Src);
g.drawImage(dst, 0, 0, null);
} finally {
g.dispose();
}
}
return origDst;
}
Transforms the source Raster
and stores the results in
the destination Raster
. This operation performs the
transform band by band.
If the destination Raster
is null, a new
Raster
is created.
An IllegalArgumentException
may be thrown if the source is
the same as the destination or if the number of bands in
the source is not equal to the number of bands in the
destination.
The coordinates of the rectangle returned by
getBounds2D(Raster)
are not necessarily the same as the coordinates of the
WritableRaster
returned by this method. If the
upper-left corner coordinates of rectangle are negative then
this part of the rectangle is not drawn. If the coordinates
of the rectangle are positive then the filtered image is drawn at
that position in the destination Raster
.
Params: - src – The
Raster
to transform. - dst – The
Raster
in which to store the results of the
transformation.
Throws: - ImagingOpException – if the raster cannot be transformed
because of a data-processing error that might be
caused by an invalid image format, tile format, or
image-processing operation, or any other unsupported
operation.
Returns: The transformed Raster
.
/**
* Transforms the source <CODE>Raster</CODE> and stores the results in
* the destination <CODE>Raster</CODE>. This operation performs the
* transform band by band.
* <p>
* If the destination <CODE>Raster</CODE> is null, a new
* <CODE>Raster</CODE> is created.
* An <CODE>IllegalArgumentException</CODE> may be thrown if the source is
* the same as the destination or if the number of bands in
* the source is not equal to the number of bands in the
* destination.
* <p>
* The coordinates of the rectangle returned by
* <code>getBounds2D(Raster)</code>
* are not necessarily the same as the coordinates of the
* <code>WritableRaster</code> returned by this method. If the
* upper-left corner coordinates of rectangle are negative then
* this part of the rectangle is not drawn. If the coordinates
* of the rectangle are positive then the filtered image is drawn at
* that position in the destination <code>Raster</code>.
* <p>
* @param src The <CODE>Raster</CODE> to transform.
* @param dst The <CODE>Raster</CODE> in which to store the results of the
* transformation.
*
* @return The transformed <CODE>Raster</CODE>.
*
* @throws ImagingOpException if the raster cannot be transformed
* because of a data-processing error that might be
* caused by an invalid image format, tile format, or
* image-processing operation, or any other unsupported
* operation.
*/
public final WritableRaster filter(Raster src, WritableRaster dst) {
if (src == null) {
throw new NullPointerException("src image is null");
}
if (dst == null) {
dst = createCompatibleDestRaster(src);
}
if (src == dst) {
throw new IllegalArgumentException("src image cannot be the "+
"same as the dst image");
}
if (src.getNumBands() != dst.getNumBands()) {
throw new IllegalArgumentException("Number of src bands ("+
src.getNumBands()+
") does not match number of "+
" dst bands ("+
dst.getNumBands()+")");
}
if (ImagingLib.filter(this, src, dst) == null) {
throw new ImagingOpException ("Unable to transform src image");
}
return dst;
}
Returns the bounding box of the transformed destination. The
rectangle returned is the actual bounding box of the
transformed points. The coordinates of the upper-left corner
of the returned rectangle might not be (0, 0).
Params: - src – The
BufferedImage
to be transformed.
Returns: The Rectangle2D
representing the destination's
bounding box.
/**
* Returns the bounding box of the transformed destination. The
* rectangle returned is the actual bounding box of the
* transformed points. The coordinates of the upper-left corner
* of the returned rectangle might not be (0, 0).
*
* @param src The <CODE>BufferedImage</CODE> to be transformed.
*
* @return The <CODE>Rectangle2D</CODE> representing the destination's
* bounding box.
*/
public final Rectangle2D getBounds2D (BufferedImage src) {
return getBounds2D(src.getRaster());
}
Returns the bounding box of the transformed destination. The
rectangle returned will be the actual bounding box of the
transformed points. The coordinates of the upper-left corner
of the returned rectangle might not be (0, 0).
Params: - src – The
Raster
to be transformed.
Returns: The Rectangle2D
representing the destination's
bounding box.
/**
* Returns the bounding box of the transformed destination. The
* rectangle returned will be the actual bounding box of the
* transformed points. The coordinates of the upper-left corner
* of the returned rectangle might not be (0, 0).
*
* @param src The <CODE>Raster</CODE> to be transformed.
*
* @return The <CODE>Rectangle2D</CODE> representing the destination's
* bounding box.
*/
public final Rectangle2D getBounds2D (Raster src) {
int w = src.getWidth();
int h = src.getHeight();
// Get the bounding box of the src and transform the corners
float[] pts = {0, 0, w, 0, w, h, 0, h};
xform.transform(pts, 0, pts, 0, 4);
// Get the min, max of the dst
float fmaxX = pts[0];
float fmaxY = pts[1];
float fminX = pts[0];
float fminY = pts[1];
for (int i=2; i < 8; i+=2) {
if (pts[i] > fmaxX) {
fmaxX = pts[i];
}
else if (pts[i] < fminX) {
fminX = pts[i];
}
if (pts[i+1] > fmaxY) {
fmaxY = pts[i+1];
}
else if (pts[i+1] < fminY) {
fminY = pts[i+1];
}
}
return new Rectangle2D.Float(fminX, fminY, fmaxX-fminX, fmaxY-fminY);
}
Creates a zeroed destination image with the correct size and number of
bands. A RasterFormatException
may be thrown if the
transformed width or height is equal to 0.
If destCM
is null,
an appropriate ColorModel
is used; this
ColorModel
may have
an alpha channel even if the source ColorModel
is opaque.
Params: - src – The
BufferedImage
to be transformed. - destCM –
ColorModel
of the destination. If null,
an appropriate ColorModel
is used.
Returns: The zeroed destination image.
/**
* Creates a zeroed destination image with the correct size and number of
* bands. A <CODE>RasterFormatException</CODE> may be thrown if the
* transformed width or height is equal to 0.
* <p>
* If <CODE>destCM</CODE> is null,
* an appropriate <CODE>ColorModel</CODE> is used; this
* <CODE>ColorModel</CODE> may have
* an alpha channel even if the source <CODE>ColorModel</CODE> is opaque.
*
* @param src The <CODE>BufferedImage</CODE> to be transformed.
* @param destCM <CODE>ColorModel</CODE> of the destination. If null,
* an appropriate <CODE>ColorModel</CODE> is used.
*
* @return The zeroed destination image.
*/
public BufferedImage createCompatibleDestImage (BufferedImage src,
ColorModel destCM) {
BufferedImage image;
Rectangle r = getBounds2D(src).getBounds();
// If r.x (or r.y) is < 0, then we want to only create an image
// that is in the positive range.
// If r.x (or r.y) is > 0, then we need to create an image that
// includes the translation.
int w = r.x + r.width;
int h = r.y + r.height;
if (w <= 0) {
throw new RasterFormatException("Transformed width ("+w+
") is less than or equal to 0.");
}
if (h <= 0) {
throw new RasterFormatException("Transformed height ("+h+
") is less than or equal to 0.");
}
if (destCM == null) {
ColorModel cm = src.getColorModel();
if (interpolationType != TYPE_NEAREST_NEIGHBOR &&
(cm instanceof IndexColorModel ||
cm.getTransparency() == Transparency.OPAQUE))
{
image = new BufferedImage(w, h,
BufferedImage.TYPE_INT_ARGB);
}
else {
image = new BufferedImage(cm,
src.getRaster().createCompatibleWritableRaster(w,h),
cm.isAlphaPremultiplied(), null);
}
}
else {
image = new BufferedImage(destCM,
destCM.createCompatibleWritableRaster(w,h),
destCM.isAlphaPremultiplied(), null);
}
return image;
}
Creates a zeroed destination Raster
with the correct size
and number of bands. A RasterFormatException
may be thrown
if the transformed width or height is equal to 0.
Params: - src – The
Raster
to be transformed.
Returns: The zeroed destination Raster
.
/**
* Creates a zeroed destination <CODE>Raster</CODE> with the correct size
* and number of bands. A <CODE>RasterFormatException</CODE> may be thrown
* if the transformed width or height is equal to 0.
*
* @param src The <CODE>Raster</CODE> to be transformed.
*
* @return The zeroed destination <CODE>Raster</CODE>.
*/
public WritableRaster createCompatibleDestRaster (Raster src) {
Rectangle2D r = getBounds2D(src);
return src.createCompatibleWritableRaster((int)r.getX(),
(int)r.getY(),
(int)r.getWidth(),
(int)r.getHeight());
}
Returns the location of the corresponding destination point given a
point in the source. If dstPt
is specified, it
is used to hold the return value.
Params: - srcPt – The
Point2D
that represents the source
point. - dstPt – The
Point2D
in which to store the result.
Returns: The Point2D
in the destination that corresponds to
the specified point in the source.
/**
* Returns the location of the corresponding destination point given a
* point in the source. If <CODE>dstPt</CODE> is specified, it
* is used to hold the return value.
*
* @param srcPt The <code>Point2D</code> that represents the source
* point.
* @param dstPt The <CODE>Point2D</CODE> in which to store the result.
*
* @return The <CODE>Point2D</CODE> in the destination that corresponds to
* the specified point in the source.
*/
public final Point2D getPoint2D (Point2D srcPt, Point2D dstPt) {
return xform.transform (srcPt, dstPt);
}
Returns the affine transform used by this transform operation.
Returns: The AffineTransform
associated with this op.
/**
* Returns the affine transform used by this transform operation.
*
* @return The <CODE>AffineTransform</CODE> associated with this op.
*/
public final AffineTransform getTransform() {
return (AffineTransform) xform.clone();
}
Returns the rendering hints used by this transform operation.
Returns: The RenderingHints
object associated with this op.
/**
* Returns the rendering hints used by this transform operation.
*
* @return The <CODE>RenderingHints</CODE> object associated with this op.
*/
public final RenderingHints getRenderingHints() {
if (hints == null) {
Object val;
switch(interpolationType) {
case TYPE_NEAREST_NEIGHBOR:
val = RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
break;
case TYPE_BILINEAR:
val = RenderingHints.VALUE_INTERPOLATION_BILINEAR;
break;
case TYPE_BICUBIC:
val = RenderingHints.VALUE_INTERPOLATION_BICUBIC;
break;
default:
// Should never get here
throw new InternalError("Unknown interpolation type "+
interpolationType);
}
hints = new RenderingHints(RenderingHints.KEY_INTERPOLATION, val);
}
return hints;
}
// We need to be able to invert the transform if we want to
// transform the image. If the determinant of the matrix is 0,
// then we can't invert the transform.
void validateTransform(AffineTransform xform) {
if (Math.abs(xform.getDeterminant()) <= Double.MIN_VALUE) {
throw new ImagingOpException("Unable to invert transform "+xform);
}
}
}