/*

 * 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.image.ImageConsumer;

import java.awt.image.ColorModel;

/**

 * This class provides an easy way to create an ImageFilter which modifies

 * the pixels of an image in the default RGB ColorModel.  It is meant to

 * be used in conjunction with a FilteredImageSource object to produce

 * filtered versions of existing images.  It is an abstract class that

 * provides the calls needed to channel all of the pixel data through a

 * single method which converts pixels one at a time in the default RGB

 * ColorModel regardless of the ColorModel being used by the ImageProducer.

 * The only method which needs to be defined to create a useable image

 * filter is the filterRGB method.  Here is an example of a definition

 * of a filter which swaps the red and blue components of an image:

 * <pre>{@code

 *

 *      class RedBlueSwapFilter extends RGBImageFilter {

 *          public RedBlueSwapFilter() {

 *              // The filter's operation does not depend on the

 *              // pixel's location, so IndexColorModels can be

 *              // filtered directly.

 *              canFilterIndexColorModel = true;

 *          }

 *

 *          public int filterRGB(int x, int y, int rgb) {

 *              return ((rgb & 0xff00ff00)

 *                      | ((rgb & 0xff0000) >> 16)

 *                      | ((rgb & 0xff) << 16));

 *          }

 *      }

 *

 * }</pre>

 *

 * @see FilteredImageSource

 * @see ImageFilter

 * @see ColorModel#getRGBdefault

 *

 * @author      Jim Graham

 */

public abstract class RGBImageFilter extends ImageFilter {

    /**

     * The {@code ColorModel} to be replaced by

     * {@code newmodel} when the user calls

     * {@link #substituteColorModel(ColorModel, ColorModel) substituteColorModel}.

     */

    protected ColorModel origmodel;

    /**

     * The {@code ColorModel} with which to

     * replace {@code origmodel} when the user calls

     * {@code substituteColorModel}.

     */

    protected ColorModel newmodel;

    /**

     * This boolean indicates whether or not it is acceptable to apply

     * the color filtering of the filterRGB method to the color table

     * entries of an IndexColorModel object in lieu of pixel by pixel

     * filtering.  Subclasses should set this variable to true in their

     * constructor if their filterRGB method does not depend on the

     * coordinate of the pixel being filtered.

     * @see #substituteColorModel

     * @see #filterRGB

     * @see IndexColorModel

     */

    protected boolean canFilterIndexColorModel;

    /**

     * If the ColorModel is an IndexColorModel and the subclass has

     * set the canFilterIndexColorModel flag to true, we substitute

     * a filtered version of the color model here and wherever

     * that original ColorModel object appears in the setPixels methods.

     * If the ColorModel is not an IndexColorModel or is null, this method

     * overrides the default ColorModel used by the ImageProducer and

     * specifies the default RGB ColorModel instead.

     * <p>

     * Note: This method is intended to be called by the

     * {@code ImageProducer} of the {@code Image} whose pixels

     * are being filtered. Developers using

     * this class to filter pixels from an image should avoid calling

     * this method directly since that operation could interfere

     * with the filtering operation.

     * @see ImageConsumer

     * @see ColorModel#getRGBdefault

     */

    public void setColorModel(ColorModel model) {

        if (canFilterIndexColorModel && (model instanceof IndexColorModel)) {

            ColorModel newcm = filterIndexColorModel((IndexColorModel)model);

            substituteColorModel(model, newcm);

            consumer.setColorModel(newcm);

        } else {

            consumer.setColorModel(ColorModel.getRGBdefault());

        }

    }

    /**

     * Registers two ColorModel objects for substitution.  If the oldcm

     * is encountered during any of the setPixels methods, the newcm

     * is substituted and the pixels passed through

     * untouched (but with the new ColorModel object).

     * @param oldcm the ColorModel object to be replaced on the fly

     * @param newcm the ColorModel object to replace oldcm on the fly

     */

    public void substituteColorModel(ColorModel oldcm, ColorModel newcm) {

        origmodel = oldcm;

        newmodel = newcm;

    }

    /**

     * Filters an IndexColorModel object by running each entry in its

     * color tables through the filterRGB function that RGBImageFilter

     * subclasses must provide.  Uses coordinates of -1 to indicate that

     * a color table entry is being filtered rather than an actual

     * pixel value.

     * @param icm the IndexColorModel object to be filtered

     * @exception NullPointerException if {@code icm} is null

     * @return a new IndexColorModel representing the filtered colors

     */

    public IndexColorModel filterIndexColorModel(IndexColorModel icm) {

        int mapsize = icm.getMapSize();

        icm.getReds(r);

        icm.getGreens(g);

        icm.getBlues(b);

        icm.getAlphas(a);

        int trans = icm.getTransparentPixel();

        boolean needalpha = false;

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

            int rgb = filterRGB(-1, -1, icm.getRGB(i));

            a[i] = (byte) (rgb >> 24);

            if (a[i] != ((byte)0xff) && i != trans) {

                needalpha = true;

            }

            r[i] = (byte) (rgb >> 16);

            g[i] = (byte) (rgb >> 8);

            b[i] = (byte) (rgb >> 0);

        }

        if (needalpha) {

            return new IndexColorModel(icm.getPixelSize(), mapsize,

                                       r, g, b, a);

        } else {

            return new IndexColorModel(icm.getPixelSize(), mapsize,

                                       r, g, b, trans);

        }

    }

    /**

     * Filters a buffer of pixels in the default RGB ColorModel by passing

     * them one by one through the filterRGB method.

     * @param x the X coordinate of the upper-left corner of the region

     *          of pixels

     * @param y the Y coordinate of the upper-left corner of the region

     *          of pixels

     * @param w the width of the region of pixels

     * @param h the height of the region of pixels

     * @param pixels the array of pixels

     * @param off the offset into the {@code pixels} array

     * @param scansize the distance from one row of pixels to the next

     *        in the array

     * @see ColorModel#getRGBdefault

     * @see #filterRGB

     */

    public void filterRGBPixels(int x, int y, int w, int h,

        int index = off;

        for (int cy = 0; cy < h; cy++) {

            for (int cx = 0; cx < w; cx++) {

                pixels[index] = filterRGB(x + cx, y + cy, pixels[index]);

                index++;

            }

            index += scansize - w;

        }

        consumer.setPixels(x, y, w, h, ColorModel.getRGBdefault(),

                           pixels, off, scansize);

    }

    /**

     * If the ColorModel object is the same one that has already

     * been converted, then simply passes the pixels through with the

     * converted ColorModel. Otherwise converts the buffer of byte

     * pixels to the default RGB ColorModel and passes the converted

     * buffer to the filterRGBPixels method to be converted one by one.

     * <p>

     * Note: This method is intended to be called by the

     * {@code ImageProducer} of the {@code Image} whose pixels

     * are being filtered. Developers using

     * this class to filter pixels from an image should avoid calling

     * this method directly since that operation could interfere

     * with the filtering operation.

     * @see ColorModel#getRGBdefault

     * @see #filterRGBPixels

     */

    public void setPixels(int x, int y, int w, int h,

                          int scansize) {

        if (model == origmodel) {

            consumer.setPixels(x, y, w, h, newmodel, pixels, off, scansize);

        } else {

            int index = off;

            for (int cy = 0; cy < h; cy++) {

                for (int cx = 0; cx < w; cx++) {

                    filteredpixels[cx] = model.getRGB((pixels[index] & 0xff));

                    index++;

                }

                index += scansize - w;

                filterRGBPixels(x, y + cy, w, 1, filteredpixels, 0, w);

            }

        }

    }

    /**

     * If the ColorModel object is the same one that has already

     * been converted, then simply passes the pixels through with the

     * converted ColorModel, otherwise converts the buffer of integer

     * pixels to the default RGB ColorModel and passes the converted

     * buffer to the filterRGBPixels method to be converted one by one.

     * Converts a buffer of integer pixels to the default RGB ColorModel

     * and passes the converted buffer to the filterRGBPixels method.

     * <p>

     * Note: This method is intended to be called by the

     * {@code ImageProducer} of the {@code Image} whose pixels

     * are being filtered. Developers using

     * this class to filter pixels from an image should avoid calling

     * this method directly since that operation could interfere

     * with the filtering operation.

     * @see ColorModel#getRGBdefault

     * @see #filterRGBPixels

     */

    public void setPixels(int x, int y, int w, int h,

                          int scansize) {

        if (model == origmodel) {

            consumer.setPixels(x, y, w, h, newmodel, pixels, off, scansize);

        } else {

            int index = off;

            for (int cy = 0; cy < h; cy++) {

                for (int cx = 0; cx < w; cx++) {

                    filteredpixels[cx] = model.getRGB(pixels[index]);

                    index++;

                }

                index += scansize - w;

                filterRGBPixels(x, y + cy, w, 1, filteredpixels, 0, w);

            }

        }

    }

    /**

     * Subclasses must specify a method to convert a single input pixel

     * in the default RGB ColorModel to a single output pixel.

     * @param x the X coordinate of the pixel

     * @param y the Y coordinate of the pixel

     * @param rgb the integer pixel representation in the default RGB

     *            color model

     * @return a filtered pixel in the default RGB color model.

     * @see ColorModel#getRGBdefault

     * @see #filterRGBPixels

     */

    public abstract int filterRGB(int x, int y, int rgb);

}