Java tutorial
/* * Copyright (c) 1995, 2018, 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.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(); byte[] r = new byte[mapsize]; byte[] g = new byte[mapsize]; byte[] b = new byte[mapsize]; byte[] a = new byte[mapsize]; 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[] pixels, int off, int scansize) { 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, ColorModel model, byte[] pixels, int off, int scansize) { if (model == origmodel) { consumer.setPixels(x, y, w, h, newmodel, pixels, off, scansize); } else { int[] filteredpixels = new int[w]; 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, ColorModel model, int[] pixels, int off, int scansize) { if (model == origmodel) { consumer.setPixels(x, y, w, h, newmodel, pixels, off, scansize); } else { int[] filteredpixels = new int[w]; 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); }