| /* | |
| * Copyright (c) 1997, 2014, 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 {@code Raster} to 2D coordinates | |
| * in the destination image or {@code Raster}. | |
| * The type of interpolation that is used is specified through a constructor, | |
| * either by a {@code RenderingHints} object or by one of the integer | |
| * interpolation types defined in this class. | |
| * <p> | |
| * If a {@code 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. | |
| * <p> | |
| * Note that the following constraints have to be met: | |
| * <ul> | |
| * <li>The source and destination must be different. | |
| * <li>For {@code Raster} 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. | |
| */ | |
| @Native public static final int TYPE_NEAREST_NEIGHBOR = 1; | |
| /** | |
| * Bilinear interpolation type. | |
| */ | |
| @Native public static final int TYPE_BILINEAR = 2; | |
| /** | |
| * Bicubic interpolation type. | |
| */ | |
| @Native public static final int TYPE_BICUBIC = 3; | |
| int interpolationType = TYPE_NEAREST_NEIGHBOR; | |
| /** | |
| * Constructs an {@code AffineTransformOp} given an affine transform. | |
| * The interpolation type is determined from the | |
| * {@code 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 ({@code hints} is null), | |
| * the interpolation type is {@link #TYPE_NEAREST_NEIGHBOR | |
| * TYPE_NEAREST_NEIGHBOR}. | |
| * | |
| * @param xform The {@code AffineTransform} to use for the | |
| * operation. | |
| * | |
| * @param hints The {@code RenderingHints} 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(RenderingHints.KEY_INTERPOLATION); | |
| if (value == null) { | |
| value = hints.get(RenderingHints.KEY_RENDERING); | |
| if (value == RenderingHints.VALUE_RENDER_SPEED) { | |
| interpolationType = TYPE_NEAREST_NEIGHBOR; | |
| } | |
| else if (value == RenderingHints.VALUE_RENDER_QUALITY) { | |
| interpolationType = TYPE_BILINEAR; | |
| } | |
| } | |
| else if (value == RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR) { | |
| interpolationType = TYPE_NEAREST_NEIGHBOR; | |
| } | |
| else if (value == RenderingHints.VALUE_INTERPOLATION_BILINEAR) { | |
| interpolationType = TYPE_BILINEAR; | |
| } | |
| else if (value == RenderingHints.VALUE_INTERPOLATION_BICUBIC) { | |
| interpolationType = TYPE_BICUBIC; | |
| } | |
| } | |
| else { | |
| interpolationType = TYPE_NEAREST_NEIGHBOR; | |
| } | |
| } | |
| /** | |
| * Constructs an {@code AffineTransformOp} given an affine transform | |
| * and the interpolation type. | |
| * | |
| * @param xform The {@code AffineTransform} 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. | |
| * @return the interpolation type. | |
| * @see #TYPE_NEAREST_NEIGHBOR | |
| * @see #TYPE_BILINEAR | |
| * @see #TYPE_BICUBIC | |
| */ | |
| public final int getInterpolationType() { | |
| return interpolationType; | |
| } | |
| /** | |
| * Transforms the source {@code BufferedImage} and stores the results | |
| * in the destination {@code 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 {@code BufferedImage} is created with the source | |
| * {@code ColorModel}. | |
| * <p> | |
| * The coordinates of the rectangle returned by | |
| * {@code getBounds2D(BufferedImage)} | |
| * are not necessarily the same as the coordinates of the | |
| * {@code 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 {@code BufferedImage}. | |
| * <p> | |
| * An {@code IllegalArgumentException} is thrown if the source is | |
| * the same as the destination. | |
| * | |
| * @param src The {@code BufferedImage} to transform. | |
| * @param dst The {@code BufferedImage} in which to store the results | |
| * of the transformation. | |
| * | |
| * @return The filtered {@code BufferedImage}. | |
| * @throws IllegalArgumentException if {@code src} and | |
| * {@code dst} 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& | |
| (AffineTransform.TYPE_MASK_ROTATION| | |
| AffineTransform.TYPE_GENERAL_TRANSFORM)) | |
| != 0); | |
| if (! needTrans && | |
| type != AffineTransform.TYPE_TRANSLATION && | |
| type != AffineTransform.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 {@code Raster} and stores the results in | |
| * the destination {@code Raster}. This operation performs the | |
| * transform band by band. | |
| * <p> | |
| * If the destination {@code Raster} is null, a new | |
| * {@code Raster} is created. | |
| * An {@code 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. | |
| * <p> | |
| * The coordinates of the rectangle returned by | |
| * {@code getBounds2D(Raster)} | |
| * are not necessarily the same as the coordinates of the | |
| * {@code 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 {@code Raster}. | |
| * | |
| * @param src The {@code Raster} to transform. | |
| * @param dst The {@code Raster} in which to store the results of the | |
| * transformation. | |
| * | |
| * @return The transformed {@code Raster}. | |
| * | |
| * @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). | |
| * | |
| * @param src The {@code BufferedImage} to be transformed. | |
| * | |
| * @return The {@code Rectangle2D} 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). | |
| * | |
| * @param src The {@code Raster} to be transformed. | |
| * | |
| * @return The {@code Rectangle2D} 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 {@code RasterFormatException} may be thrown if the | |
| * transformed width or height is equal to 0. | |
| * <p> | |
| * If {@code destCM} is null, | |
| * an appropriate {@code ColorModel} is used; this | |
| * {@code ColorModel} may have | |
| * an alpha channel even if the source {@code ColorModel} is opaque. | |
| * | |
| * @param src The {@code BufferedImage} to be transformed. | |
| * @param destCM {@code ColorModel} of the destination. If null, | |
| * an appropriate {@code ColorModel} 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 {@code Raster} with the correct size | |
| * and number of bands. A {@code RasterFormatException} may be thrown | |
| * if the transformed width or height is equal to 0. | |
| * | |
| * @param src The {@code Raster} to be transformed. | |
| * | |
| * @return The zeroed destination {@code Raster}. | |
| */ | |
| 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 {@code dstPt} is specified, it | |
| * is used to hold the return value. | |
| * | |
| * @param srcPt The {@code Point2D} that represents the source | |
| * point. | |
| * @param dstPt The {@code Point2D} in which to store the result. | |
| * | |
| * @return The {@code Point2D} 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. | |
| * | |
| * @return The {@code AffineTransform} associated with this op. | |
| */ | |
| public final AffineTransform getTransform() { | |
| return (AffineTransform) xform.clone(); | |
| } | |
| /** | |
| * Returns the rendering hints used by this transform operation. | |
| * | |
| * @return The {@code RenderingHints} 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); | |
| } | |
| } | |
| } |