/*

 * 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);

    }

    /**