| /* |
| * Copyright (c) 1997, 2000, 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.color.ColorSpace; |
| import java.awt.geom.Rectangle2D; |
| import java.awt.Rectangle; |
| import java.awt.RenderingHints; |
| import java.awt.geom.Point2D; |
| import sun.awt.image.ImagingLib; |
| |
| /** |
| * This class implements a lookup operation from the source |
| * to the destination. The LookupTable object may contain a single array |
| * or multiple arrays, subject to the restrictions below. |
| * <p> |
| * For Rasters, the lookup operates on bands. The number of |
| * lookup arrays may be one, in which case the same array is |
| * applied to all bands, or it must equal the number of Source |
| * Raster bands. |
| * <p> |
| * For BufferedImages, the lookup operates on color and alpha components. |
| * The number of lookup arrays may be one, in which case the |
| * same array is applied to all color (but not alpha) components. |
| * Otherwise, the number of lookup arrays may |
| * equal the number of Source color components, in which case no |
| * lookup of the alpha component (if present) is performed. |
| * If neither of these cases apply, the number of lookup arrays |
| * must equal the number of Source color components plus alpha components, |
| * in which case lookup is performed for all color and alpha components. |
| * This allows non-uniform rescaling of multi-band BufferedImages. |
| * <p> |
| * BufferedImage sources with premultiplied alpha data are treated in the same |
| * manner as non-premultiplied images for purposes of the lookup. That is, |
| * the lookup 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 used. |
| * <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> |
| * This class allows the Source to be the same as the Destination. |
| * |
| * @see LookupTable |
| * @see java.awt.RenderingHints#KEY_COLOR_RENDERING |
| * @see java.awt.RenderingHints#KEY_DITHERING |
| */ |
| |
| public class LookupOp implements BufferedImageOp, RasterOp { |
| private LookupTable ltable; |
| private int numComponents; |
| RenderingHints hints; |
| |
| /** |
| * Constructs a <code>LookupOp</code> object given the lookup |
| * table and a <code>RenderingHints</code> object, which might |
| * be <code>null</code>. |
| * @param lookup the specified <code>LookupTable</code> |
| * @param hints the specified <code>RenderingHints</code>, |
| * or <code>null</code> |
| */ |
| public LookupOp(LookupTable lookup, RenderingHints hints) { |
| this.ltable = lookup; |
| this.hints = hints; |
| numComponents = ltable.getNumComponents(); |
| } |
| |
| /** |
| * Returns the <code>LookupTable</code>. |
| * @return the <code>LookupTable</code> of this |
| * <code>LookupOp</code>. |
| */ |
| public final LookupTable getTable() { |
| return ltable; |
| } |
| |
| /** |
| * Performs a lookup operation on a <code>BufferedImage</code>. |
| * 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 <code>null</code>, |
| * a <code>BufferedImage</code> will be created with an appropriate |
| * <code>ColorModel</code>. An <code>IllegalArgumentException</code> |
| * might be thrown if the number of arrays in the |
| * <code>LookupTable</code> does not meet the restrictions |
| * stated in the class comment above, or if the source image |
| * has an <code>IndexColorModel</code>. |
| * @param src the <code>BufferedImage</code> to be filtered |
| * @param dst the <code>BufferedImage</code> in which to |
| * store the results of the filter operation |
| * @return the filtered <code>BufferedImage</code>. |
| * @throws IllegalArgumentException if the number of arrays in the |
| * <code>LookupTable</code> does not meet the restrictions |
| * described in the class comments, or if the source image |
| * has an <code>IndexColorModel</code>. |
| */ |
| public final BufferedImage filter(BufferedImage src, BufferedImage dst) { |
| ColorModel srcCM = src.getColorModel(); |
| int numBands = srcCM.getNumColorComponents(); |
| ColorModel dstCM; |
| if (srcCM instanceof IndexColorModel) { |
| throw new |
| IllegalArgumentException("LookupOp cannot be "+ |
| "performed on an indexed image"); |
| } |
| int numComponents = ltable.getNumComponents(); |
| if (numComponents != 1 && |
| numComponents != srcCM.getNumComponents() && |
| numComponents != srcCM.getNumColorComponents()) |
| { |
| throw new IllegalArgumentException("Number of arrays in the "+ |
| " lookup table ("+ |
| numComponents+ |
| " is not compatible with the "+ |
| " src image: "+src); |
| } |
| |
| |
| boolean needToConvert = false; |
| |
| int width = src.getWidth(); |
| int height = src.getHeight(); |
| |
| 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); |
| } |
| |
| } |
| |
| BufferedImage origDst = dst; |
| |
| if (ImagingLib.filter(this, src, dst) == null) { |
| // Do it the slow way |
| WritableRaster srcRaster = src.getRaster(); |
| WritableRaster dstRaster = dst.getRaster(); |
| |
| if (srcCM.hasAlpha()) { |
| if (numBands-1 == numComponents || numComponents == 1) { |
| int minx = srcRaster.getMinX(); |
| int miny = srcRaster.getMinY(); |
| int[] bands = new int[numBands-1]; |
| for (int i=0; i < numBands-1; i++) { |
| bands[i] = i; |
| } |
| srcRaster = |
| srcRaster.createWritableChild(minx, miny, |
| srcRaster.getWidth(), |
| srcRaster.getHeight(), |
| minx, miny, |
| bands); |
| } |
| } |
| if (dstCM.hasAlpha()) { |
| int dstNumBands = dstRaster.getNumBands(); |
| if (dstNumBands-1 == numComponents || numComponents == 1) { |
| int minx = dstRaster.getMinX(); |
| int miny = dstRaster.getMinY(); |
| int[] bands = new int[numBands-1]; |
| for (int i=0; i < numBands-1; i++) { |
| bands[i] = i; |
| } |
| dstRaster = |
| dstRaster.createWritableChild(minx, miny, |
| dstRaster.getWidth(), |
| dstRaster.getHeight(), |
| minx, miny, |
| bands); |
| } |
| } |
| |
| filter(srcRaster, dstRaster); |
| } |
| |
| if (needToConvert) { |
| // ColorModels are not the same |
| ColorConvertOp ccop = new ColorConvertOp(hints); |
| ccop.filter(dst, origDst); |
| } |
| |
| return origDst; |
| } |
| |
| /** |
| * Performs a lookup operation on a <code>Raster</code>. |
| * If the destination <code>Raster</code> is <code>null</code>, |
| * a new <code>Raster</code> will be created. |
| * The <code>IllegalArgumentException</code> might be thrown |
| * if the source <code>Raster</code> and the destination |
| * <code>Raster</code> do not have the same |
| * number of bands or if the number of arrays in the |
| * <code>LookupTable</code> does not meet the |
| * restrictions stated in the class comment above. |
| * @param src the source <code>Raster</code> to filter |
| * @param dst the destination <code>WritableRaster</code> for the |
| * filtered <code>src</code> |
| * @return the filtered <code>WritableRaster</code>. |
| * @throws IllegalArgumentException if the source and destinations |
| * rasters do not have the same number of bands, or the |
| * number of arrays in the <code>LookupTable</code> does |
| * not meet the restrictions described in the class comments. |
| * |
| */ |
| public final WritableRaster filter (Raster src, WritableRaster dst) { |
| int numBands = src.getNumBands(); |
| int dstLength = dst.getNumBands(); |
| int height = src.getHeight(); |
| int width = src.getWidth(); |
| int srcPix[] = new int[numBands]; |
| |
| // 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"); |
| } |
| dstLength = dst.getNumBands(); |
| |
| if (numBands != dstLength) { |
| throw new |
| IllegalArgumentException ("Number of channels in the src (" |
| + numBands + |
| ") does not match number of channels" |
| + " in the destination (" |
| + dstLength + ")"); |
| } |
| int numComponents = ltable.getNumComponents(); |
| if (numComponents != 1 && numComponents != src.getNumBands()) { |
| throw new IllegalArgumentException("Number of arrays in the "+ |
| " lookup table ("+ |
| numComponents+ |
| " is not compatible with the "+ |
| " src Raster: "+src); |
| } |
| |
| |
| if (ImagingLib.filter(this, src, dst) != null) { |
| return dst; |
| } |
| |
| // Optimize for cases we know about |
| if (ltable instanceof ByteLookupTable) { |
| byteFilter ((ByteLookupTable) ltable, src, dst, |
| width, height, numBands); |
| } |
| else if (ltable instanceof ShortLookupTable) { |
| shortFilter ((ShortLookupTable) ltable, src, dst, width, |
| height, numBands); |
| } |
| else { |
| // Not one we recognize so do it slowly |
| int sminX = src.getMinX(); |
| int sY = src.getMinY(); |
| int dminX = dst.getMinX(); |
| int dY = dst.getMinY(); |
| for (int y=0; y < height; y++, sY++, dY++) { |
| int sX = sminX; |
| int dX = dminX; |
| for (int x=0; x < width; x++, sX++, dX++) { |
| // Find data for all bands at this x,y position |
| src.getPixel(sX, sY, srcPix); |
| |
| // Lookup the data for all bands at this x,y position |
| ltable.lookupPixel(srcPix, srcPix); |
| |
| // Put it back for all bands |
| dst.setPixel(dX, dY, srcPix); |
| } |
| } |
| } |
| |
| return dst; |
| } |
| |
| /** |
| * Returns the bounding box of the filtered destination image. Since |
| * this is not a geometric operation, the bounding box does not |
| * change. |
| * @param src the <code>BufferedImage</code> to be filtered |
| * @return the bounds of the filtered definition image. |
| */ |
| public final Rectangle2D getBounds2D (BufferedImage src) { |
| return getBounds2D(src.getRaster()); |
| } |
| |
| /** |
| * Returns the bounding box of the filtered destination Raster. Since |
| * this is not a geometric operation, the bounding box does not |
| * change. |
| * @param src the <code>Raster</code> to be filtered |
| * @return the bounds of the filtered definition <code>Raster</code>. |
| */ |
| public final Rectangle2D getBounds2D (Raster src) { |
| return src.getBounds(); |
| |
| } |
| |
| /** |
| * Creates a zeroed destination image with the correct size and number of |
| * bands. If destCM is <code>null</code>, an appropriate |
| * <code>ColorModel</code> will be used. |
| * @param src Source image for the filter operation. |
| * @param destCM the destination's <code>ColorModel</code>, which |
| * can be <code>null</code>. |
| * @return a filtered destination <code>BufferedImage</code>. |
| */ |
| public BufferedImage createCompatibleDestImage (BufferedImage src, |
| ColorModel destCM) { |
| BufferedImage image; |
| int w = src.getWidth(); |
| int h = src.getHeight(); |
| int transferType = DataBuffer.TYPE_BYTE; |
| if (destCM == null) { |
| ColorModel cm = src.getColorModel(); |
| Raster raster = src.getRaster(); |
| if (cm instanceof ComponentColorModel) { |
| DataBuffer db = raster.getDataBuffer(); |
| boolean hasAlpha = cm.hasAlpha(); |
| boolean isPre = cm.isAlphaPremultiplied(); |
| int trans = cm.getTransparency(); |
| int[] nbits = null; |
| if (ltable instanceof ByteLookupTable) { |
| if (db.getDataType() == db.TYPE_USHORT) { |
| // Dst raster should be of type byte |
| if (hasAlpha) { |
| nbits = new int[2]; |
| if (trans == cm.BITMASK) { |
| nbits[1] = 1; |
| } |
| else { |
| nbits[1] = 8; |
| } |
| } |
| else { |
| nbits = new int[1]; |
| } |
| nbits[0] = 8; |
| } |
| // For byte, no need to change the cm |
| } |
| else if (ltable instanceof ShortLookupTable) { |
| transferType = DataBuffer.TYPE_USHORT; |
| if (db.getDataType() == db.TYPE_BYTE) { |
| if (hasAlpha) { |
| nbits = new int[2]; |
| if (trans == cm.BITMASK) { |
| nbits[1] = 1; |
| } |
| else { |
| nbits[1] = 16; |
| } |
| } |
| else { |
| nbits = new int[1]; |
| } |
| nbits[0] = 16; |
| } |
| } |
| if (nbits != null) { |
| cm = new ComponentColorModel(cm.getColorSpace(), |
| nbits, hasAlpha, isPre, |
| trans, transferType); |
| } |
| } |
| image = new BufferedImage(cm, |
| cm.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</code> with the |
| * correct size and number of bands, given this source. |
| * @param src the <code>Raster</code> to be transformed |
| * @return the zeroed-destination <code>Raster</code>. |
| */ |
| public WritableRaster createCompatibleDestRaster (Raster src) { |
| return src.createCompatibleWritableRaster(); |
| } |
| |
| /** |
| * Returns the location of the destination point given a |
| * point in the source. If <code>dstPt</code> is not |
| * <code>null</code>, it will be used to hold the return value. |
| * Since this is not a geometric operation, the <code>srcPt</code> |
| * will equal the <code>dstPt</code>. |
| * @param srcPt a <code>Point2D</code> that represents a point |
| * in the source image |
| * @param dstPt a <code>Point2D</code>that represents the location |
| * in the destination |
| * @return the <code>Point2D</code> in the destination that |
| * corresponds to the specified point in the source. |
| */ |
| public final Point2D getPoint2D (Point2D srcPt, Point2D dstPt) { |
| if (dstPt == null) { |
| dstPt = new Point2D.Float(); |
| } |
| dstPt.setLocation(srcPt.getX(), srcPt.getY()); |
| |
| return dstPt; |
| } |
| |
| /** |
| * Returns the rendering hints for this op. |
| * @return the <code>RenderingHints</code> object associated |
| * with this op. |
| */ |
| public final RenderingHints getRenderingHints() { |
| return hints; |
| } |
| |
| private final void byteFilter(ByteLookupTable lookup, Raster src, |
| WritableRaster dst, |
| int width, int height, int numBands) { |
| int[] srcPix = null; |
| |
| // Find the ref to the table and the offset |
| byte[][] table = lookup.getTable(); |
| int offset = lookup.getOffset(); |
| int tidx; |
| int step=1; |
| |
| // Check if it is one lookup applied to all bands |
| if (table.length == 1) { |
| step=0; |
| } |
| |
| int x; |
| int y; |
| int band; |
| int len = table[0].length; |
| |
| // Loop through the data |
| for ( y=0; y < height; y++) { |
| tidx = 0; |
| for ( band=0; band < numBands; band++, tidx+=step) { |
| // Find data for this band, scanline |
| srcPix = src.getSamples(0, y, width, 1, band, srcPix); |
| |
| for ( x=0; x < width; x++) { |
| int index = srcPix[x]-offset; |
| if (index < 0 || index > len) { |
| throw new |
| IllegalArgumentException("index ("+index+ |
| "(out of range: "+ |
| " srcPix["+x+ |
| "]="+ srcPix[x]+ |
| " offset="+ offset); |
| } |
| // Do the lookup |
| srcPix[x] = table[tidx][index]; |
| } |
| // Put it back |
| dst.setSamples(0, y, width, 1, band, srcPix); |
| } |
| } |
| } |
| |
| private final void shortFilter(ShortLookupTable lookup, Raster src, |
| WritableRaster dst, |
| int width, int height, int numBands) { |
| int band; |
| int[] srcPix = null; |
| |
| // Find the ref to the table and the offset |
| short[][] table = lookup.getTable(); |
| int offset = lookup.getOffset(); |
| int tidx; |
| int step=1; |
| |
| // Check if it is one lookup applied to all bands |
| if (table.length == 1) { |
| step=0; |
| } |
| |
| int x = 0; |
| int y = 0; |
| int index; |
| int maxShort = (1<<16)-1; |
| // Loop through the data |
| for (y=0; y < height; y++) { |
| tidx = 0; |
| for ( band=0; band < numBands; band++, tidx+=step) { |
| // Find data for this band, scanline |
| srcPix = src.getSamples(0, y, width, 1, band, srcPix); |
| |
| for ( x=0; x < width; x++) { |
| index = srcPix[x]-offset; |
| if (index < 0 || index > maxShort) { |
| throw new |
| IllegalArgumentException("index out of range "+ |
| index+" x is "+x+ |
| "srcPix[x]="+srcPix[x] |
| +" offset="+ offset); |
| } |
| // Do the lookup |
| srcPix[x] = table[tidx][index]; |
| } |
| // Put it back |
| dst.setSamples(0, y, width, 1, band, srcPix); |
| } |
| } |
| } |
| } |
