/*

 * 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.color.ColorSpace;

import java.awt.geom.Rectangle2D;

import java.awt.AlphaComposite;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.Point2D;

import java.awt.RenderingHints;

import sun.awt.image.ImagingLib;

/**

 * This class performs a pixel-by-pixel rescaling of the data in the

 * source image by multiplying the sample values for each pixel by a scale

 * factor and then adding an offset. The scaled sample values are clipped

 * to the minimum/maximum representable in the destination image.

 * <p>

 * The pseudo code for the rescaling operation is as follows:

 * <pre>

 *for each pixel from Source object {

 *    for each band/component of the pixel {

 *        dstElement = (srcElement*scaleFactor) + offset

 *    }

 *}

 * </pre>

 * <p>

 * For Rasters, rescaling operates on bands.  The number of

 * sets of scaling constants may be one, in which case the same constants

 * are applied to all bands, or it must equal the number of Source

 * Raster bands.

 * <p>

 * For BufferedImages, rescaling operates on color and alpha components.

 * The number of sets of scaling constants may be one, in which case the

 * same constants are applied to all color (but not alpha) components.

 * Otherwise, the  number of sets of scaling constants may

 * equal the number of Source color components, in which case no

 * rescaling of the alpha component (if present) is performed.

 * If neither of these cases apply, the number of sets of scaling constants

 * must equal the number of Source color components plus alpha components,

 * in which case all color and alpha components are rescaled.

 * <p>

 * BufferedImage sources with premultiplied alpha data are treated in the same

 * manner as non-premultiplied images for purposes of rescaling.  That is,

 * the rescaling is done per band on the raw data of the BufferedImage source

 * without regard to whether the data is premultiplied.  If a color conversion

 * is required to the destination ColorModel, the premultiplied state of

 * both source and destination will be taken into account for this step.

 * <p>

 * Images with an IndexColorModel cannot be rescaled.

 * <p>

 * If a RenderingHints object is specified in the constructor, the

 * color rendering hint and the dithering hint may be used when color

 * conversion is required.

 * <p>

 * Note that in-place operation is allowed (i.e. the source and destination can

 * be the same object).

 * @see java.awt.RenderingHints#KEY_COLOR_RENDERING

 * @see java.awt.RenderingHints#KEY_DITHERING

 */

public class RescaleOp implements BufferedImageOp, RasterOp {

    float[] scaleFactors;

    float[] offsets;

    int length = 0;

    RenderingHints hints;

    private int srcNbits;

    private int dstNbits;

    /**

     * Constructs a new RescaleOp with the desired scale factors

     * and offsets.  The length of the scaleFactor and offset arrays

     * must meet the restrictions stated in the class comments above.

     * The RenderingHints argument may be null.

     * @param scaleFactors the specified scale factors

     * @param offsets the specified offsets

     * @param hints the specified {@code RenderingHints}, or

     *        {@code null}

     */

    public RescaleOp (float[] scaleFactors, float[] offsets,

                      RenderingHints hints) {

        length = scaleFactors.length;

        if (length > offsets.length) length = offsets.length;

        this.scaleFactors = new float[length];

        this.offsets      = new float[length];

        for (int i=0; i < length; i++) {

            this.scaleFactors[i] = scaleFactors[i];

            this.offsets[i]      = offsets[i];

        }

        this.hints = hints;

    }

    /**

     * Constructs a new RescaleOp with the desired scale factor

     * and offset.  The scaleFactor and offset will be applied to

     * all bands in a source Raster and to all color (but not alpha)

     * components in a BufferedImage.

     * The RenderingHints argument may be null.

     * @param scaleFactor the specified scale factor

     * @param offset the specified offset

     * @param hints the specified {@code RenderingHints}, or

     *        {@code null}

     */

    public RescaleOp (float scaleFactor, float offset, RenderingHints hints) {

        length = 1;

        this.scaleFactors = new float[1];

        this.offsets      = new float[1];

        this.scaleFactors[0] = scaleFactor;

        this.offsets[0]       = offset;

        this.hints = hints;

    }

    /**

     * Returns the scale factors in the given array. The array is also

     * returned for convenience.  If scaleFactors is null, a new array

     * will be allocated.

     * @param scaleFactors the array to contain the scale factors of

     *        this {@code RescaleOp}

     * @return the scale factors of this {@code RescaleOp}.

     */

        if (scaleFactors == null) {

            return this.scaleFactors.clone();

        }

        System.arraycopy (this.scaleFactors, 0, scaleFactors, 0,

                          Math.min(this.scaleFactors.length,

                                   scaleFactors.length));

        return scaleFactors;

    }

    /**

     * Returns the offsets in the given array. The array is also returned

     * for convenience.  If offsets is null, a new array

     * will be allocated.

     * @param offsets the array to contain the offsets of

     *        this {@code RescaleOp}

     * @return the offsets of this {@code RescaleOp}.

     */

        if (offsets == null) {

            return this.offsets.clone();

        }

        System.arraycopy (this.offsets, 0, offsets, 0,

                          Math.min(this.offsets.length, offsets.length));

        return offsets;

    }

    /**

     * Returns the number of scaling factors and offsets used in this

     * RescaleOp.

     * @return the number of scaling factors and offsets of this

     *         {@code RescaleOp}.

     */

    public final int getNumFactors() {

        return length;

    }

    /**

     * Creates a ByteLookupTable to implement the rescale.

     * The table may have either a SHORT or BYTE input.

     * @param nElems    Number of elements the table is to have.

     *                  This will generally be 256 for byte and

     *                  65536 for short.

     */

                                          int   nBands,

                                          int   nElems) {

        byte[][]        lutData = new byte[nBands][nElems];

        int band;

        for (band=0; band<scale.length; band++) {

            float  bandScale   = scale[band];

            float  bandOff     = off[band];

            byte[] bandLutData = lutData[band];

            for (int i=0; i<nElems; i++) {

                int val = (int)(i*bandScale + bandOff);

                if ((val & 0xffffff00) != 0) {

                    if (val < 0) {

                        val = 0;

                    } else {

                        val = 255;

                    }

                }

                bandLutData[i] = (byte)val;

            }

        }

        int maxToCopy = (nBands == 4 && scale.length == 4) ? 4 : 3;

        while (band < lutData.length && band < maxToCopy) {

           System.arraycopy(lutData[band-1], 0, lutData[band], 0, nElems);

           band++;

        }

        if (nBands == 4 && band < nBands) {

           byte[] bandLutData = lutData[band];

           for (int i=0; i<nElems; i++) {

              bandLutData[i] = (byte)i;

           }

        }

        return new ByteLookupTable(0, lutData);

    }

    /**

     * Creates a ShortLookupTable to implement the rescale.

     * The table may have either a SHORT or BYTE input.

     * @param nElems    Number of elements the table is to have.

     *                  This will generally be 256 for byte and

     *                  65536 for short.

     */

                                            int   nBands,

                                            int   nElems) {

        short[][]        lutData = new short[nBands][nElems];

        int band = 0;

        for (band=0; band<scale.length; band++) {

            float   bandScale   = scale[band];

            float   bandOff     = off[band];

            short[] bandLutData = lutData[band];

            for (int i=0; i<nElems; i++) {

                int val = (int)(i*bandScale + bandOff);

                if ((val & 0xffff0000) != 0) {

                    if (val < 0) {

                        val = 0;

                    } else {

                        val = 65535;

                    }

                }

                bandLutData[i] = (short)val;

            }

        }

        int maxToCopy = (nBands == 4 && scale.length == 4) ? 4 : 3;

        while (band < lutData.length && band < maxToCopy) {

           System.arraycopy(lutData[band-1], 0, lutData[band], 0, nElems);

           band++;

        }

        if (nBands == 4 && band < nBands) {

           short[] bandLutData = lutData[band];

           for (int i=0; i<nElems; i++) {

              bandLutData[i] = (short)i;

           }

        }

        return new ShortLookupTable(0, lutData);

    }

    /**

     * Determines if the rescale can be performed as a lookup.

     * The dst must be a byte or short type.

     * The src must be less than 16 bits.

     * All source band sizes must be the same and all dst band sizes

     * must be the same.

     */

    private boolean canUseLookup(Raster src, Raster dst) {

        //

        // Check that the src datatype is either a BYTE or SHORT

        //

        int datatype = src.getDataBuffer().getDataType();

        if(datatype != DataBuffer.TYPE_BYTE &&

           datatype != DataBuffer.TYPE_USHORT) {

            return false;

        }

        //

        // Check dst sample sizes. All must be 8 or 16 bits.

        //

        SampleModel dstSM = dst.getSampleModel();

        dstNbits = dstSM.getSampleSize(0);

        if (!(dstNbits == 8 || dstNbits == 16)) {

            return false;

        }

        for (int i=1; i<src.getNumBands(); i++) {

            int bandSize = dstSM.getSampleSize(i);

            if (bandSize != dstNbits) {

                return false;

            }

        }

        //

        // Check src sample sizes. All must be the same size

        //

        SampleModel srcSM = src.getSampleModel();

        srcNbits = srcSM.getSampleSize(0);

        if (srcNbits > 16) {

            return false;

        }

        for (int i=1; i<src.getNumBands(); i++) {

            int bandSize = srcSM.getSampleSize(i);

            if (bandSize != srcNbits) {

                return false;

            }

        }

      if (dstSM instanceof ComponentSampleModel) {

           ComponentSampleModel dsm = (ComponentSampleModel)dstSM;

           if (dsm.getPixelStride() != dst.getNumBands()) {

               return false;

           }

        }

        if (srcSM instanceof ComponentSampleModel) {

           ComponentSampleModel csm = (ComponentSampleModel)srcSM;

           if (csm.getPixelStride() != src.getNumBands()) {

               return false;

           }

        }

        return true;

    }

    /**

     * Rescales the source BufferedImage.

     * If the color model in the source image is not the same as that

     * in the destination image, the pixels will be converted

     * in the destination.  If the destination image is null,

     * a BufferedImage will be created with the source ColorModel.

     * An IllegalArgumentException may be thrown if the number of

     * scaling factors/offsets in this object does not meet the

     * restrictions stated in the class comments above, or if the

     * source image has an IndexColorModel.

     * @param src the {@code BufferedImage} to be filtered

     * @param dst the destination for the filtering operation

     *            or {@code null}

     * @return the filtered {@code BufferedImage}.

     * @throws IllegalArgumentException if the {@code ColorModel}

     *         of {@code src} is an {@code IndexColorModel},

     *         or if the number of scaling factors and offsets in this

     *         {@code RescaleOp} do not meet the requirements

     *         stated in the class comments, or if the source and

     *         destination images differ in size.

     */

    public final BufferedImage filter (BufferedImage src, BufferedImage dst) {

        ColorModel srcCM = src.getColorModel();

        ColorModel dstCM;

        int numSrcColorComp = srcCM.getNumColorComponents();

        int scaleConst = length;

        if (srcCM instanceof IndexColorModel) {

            throw new

                IllegalArgumentException("Rescaling cannot be "+

                                         "performed on an indexed image");

        }

        if (scaleConst != 1 && scaleConst != numSrcColorComp &&

            scaleConst != srcCM.getNumComponents())

        {

            throw new IllegalArgumentException("Number of scaling constants "+

                                               "does not equal the number of"+

                                               " of color or color/alpha "+

                                               " components");

        }

        boolean needToConvert = false;

        boolean needToDraw = false;

        // Include alpha

        if (scaleConst > numSrcColorComp && srcCM.hasAlpha()) {

            scaleConst = numSrcColorComp+1;

        }

        int width = src.getWidth();

        int height = src.getHeight();

        BufferedImage origDst = dst;

        if (dst == null) {

            dst = createCompatibleDestImage(src, null);

            dstCM = srcCM;

        }

        else {

            if (width != dst.getWidth()) {

                throw new

                    IllegalArgumentException("Src width ("+width+

                                             ") not equal to dst width ("+

                                             dst.getWidth()+")");

            }

            if (height != dst.getHeight()) {

                throw new

                    IllegalArgumentException("Src height ("+height+

                                             ") not equal to dst height ("+

                                             dst.getHeight()+")");

            }

            dstCM = dst.getColorModel();

            if(srcCM.getColorSpace().getType() !=

                 dstCM.getColorSpace().getType()) {

                needToConvert = true;

                dst = createCompatibleDestImage(src, null);

            }

        }

        //

        // Try to use a native BI rescale operation first

        //

        if (ImagingLib.filter(this, src, dst) == null) {

            if (src.getRaster().getNumBands() !=

                dst.getRaster().getNumBands()) {

                needToDraw = true;

                dst = createCompatibleDestImage(src, null);

            }

            //

            // Native BI rescale failed - convert to rasters

            //

            WritableRaster srcRaster = src.getRaster();

            WritableRaster dstRaster = dst.getRaster();

            //

            // Call the raster filter method

            //

            filterRasterImpl(srcRaster, dstRaster, scaleConst, false);

        }

        if (needToDraw) {

             Graphics2D g = origDst.createGraphics();

             g.setComposite(AlphaComposite.Src);

             g.drawImage(dst, 0, 0, width, height, null);

             g.dispose();

        }

        if (needToConvert) {

            // ColorModels are not the same

            ColorConvertOp ccop = new ColorConvertOp(hints);

            dst = ccop.filter(dst, origDst);

        }

        return dst;

    }

    /**

     * Rescales the pixel data in the source Raster.

     * If the destination Raster is null, a new Raster will be created.

     * The source and destination must have the same number of bands.

     * Otherwise, an IllegalArgumentException is thrown.

     * Note that the number of scaling factors/offsets in this object must

     * meet the restrictions stated in the class comments above.

     * Otherwise, an IllegalArgumentException is thrown.

     * @param src the {@code Raster} to be filtered

     * @param dst the destination for the filtering operation

     *            or {@code null}

     * @return the filtered {@code WritableRaster}.

     * @throws IllegalArgumentException if {@code src} and

     *         {@code dst} do not have the same number of bands,

     *         or if the number of scaling factors and offsets in this

     *         {@code RescaleOp} do not meet the requirements

     *         stated in the class comments, or if the source and

     *         destination rasters differ in size.

     */

    public final WritableRaster filter (Raster src, WritableRaster dst)  {

        return filterRasterImpl(src, dst, length, true);

    }

    private WritableRaster filterRasterImpl(Raster src, WritableRaster dst,

                                            int scaleConst, boolean sCheck) {

        int numBands = src.getNumBands();

        int width  = src.getWidth();

        int height = src.getHeight();

        int[] srcPix = null;

        int step = 0;

        int tidx = 0;

        // Create a new destination Raster, if needed

        if (dst == null) {

            dst = createCompatibleDestRaster(src);

        }

        else if (height != dst.getHeight() || width != dst.getWidth()) {

            throw new

               IllegalArgumentException("Width or height of Rasters do not "+

                                        "match");

        }

        else if (numBands != dst.getNumBands()) {

            // Make sure that the number of bands are equal

            throw new IllegalArgumentException("Number of bands in src "

                            + numBands

                            + " does not equal number of bands in dest "

                            + dst.getNumBands());

        }

        // Make sure that the arrays match

        // Make sure that the low/high/constant arrays match

        if (sCheck && scaleConst != 1 && scaleConst != src.getNumBands()) {

            throw new IllegalArgumentException("Number of scaling constants "+

                                               "does not equal the number of"+

                                               " of bands in the src raster");