| /* | |
| * Copyright (c) 1997, 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.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} object given the lookup | |
| * table and a {@code RenderingHints} object, which might | |
| * be {@code null}. | |
| * @param lookup the specified {@code LookupTable} | |
| * @param hints the specified {@code RenderingHints}, | |
| * or {@code null} | |
| */ | |
| public LookupOp(LookupTable lookup, RenderingHints hints) { | |
| this.ltable = lookup; | |
| this.hints = hints; | |
| numComponents = ltable.getNumComponents(); | |
| } | |
| /** | |
| * Returns the {@code LookupTable}. | |
| * @return the {@code LookupTable} of this | |
| * {@code LookupOp}. | |
| */ | |
| public final LookupTable getTable() { | |
| return ltable; | |
| } | |
| /** | |
| * Performs a lookup operation on a {@code 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 {@code null}, | |
| * a {@code BufferedImage} will be created with an appropriate | |
| * {@code ColorModel}. An {@code IllegalArgumentException} | |
| * might be thrown if the number of arrays in the | |
| * {@code LookupTable} does not meet the restrictions | |
| * stated in the class comment above, or if the source image | |
| * has an {@code IndexColorModel}. | |
| * @param src the {@code BufferedImage} to be filtered | |
| * @param dst the {@code BufferedImage} in which to | |
| * store the results of the filter operation | |
| * @return the filtered {@code BufferedImage}. | |
| * @throws IllegalArgumentException if the number of arrays in the | |
| * {@code LookupTable} does not meet the restrictions | |
| * described in the class comments, or if the source image | |
| * has an {@code IndexColorModel}. | |
| */ | |
| 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}. | |
| * If the destination {@code Raster} is {@code null}, | |
| * a new {@code Raster} will be created. | |
| * The {@code IllegalArgumentException} might be thrown | |
| * if the source {@code Raster} and the destination | |
| * {@code Raster} do not have the same | |
| * number of bands or if the number of arrays in the | |
| * {@code LookupTable} does not meet the | |
| * restrictions stated in the class comment above. | |
| * @param src the source {@code Raster} to filter | |
| * @param dst the destination {@code WritableRaster} for the | |
| * filtered {@code src} | |
| * @return the filtered {@code WritableRaster}. | |
| * @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} does | |
| * not meet the restrictions described in the class comments. | |
| * | |
| */ | |
| public final WritableRaster filter (Raster src, WritableRaster dst) { | |
| int numBands = src.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"); | |
| } | |
| int 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} 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} to be filtered | |
| * @return the bounds of the filtered definition {@code Raster}. | |
| */ | |
| 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}, an appropriate | |
| * {@code ColorModel} will be used. | |
| * @param src Source image for the filter operation. | |
| * @param destCM the destination's {@code ColorModel}, which | |
| * can be {@code null}. | |
| * @return a filtered destination {@code BufferedImage}. | |
| */ | |
| 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() == DataBuffer.TYPE_USHORT) { | |
| // Dst raster should be of type byte | |
| if (hasAlpha) { | |
| nbits = new int[2]; | |
| if (trans == java.awt.Transparency.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() == DataBuffer.TYPE_BYTE) { | |
| if (hasAlpha) { | |
| nbits = new int[2]; | |
| if (trans == java.awt.Transparency.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} with the | |
| * correct size and number of bands, given this source. | |
| * @param src the {@code Raster} to be transformed | |
| * @return the zeroed-destination {@code Raster}. | |
| */ | |
| public WritableRaster createCompatibleDestRaster (Raster src) { | |
| return src.createCompatibleWritableRaster(); | |
| } | |
| /** | |
| * Returns the location of the destination point given a | |
| * point in the source. If {@code dstPt} is not | |
| * {@code null}, it will be used to hold the return value. | |
| * Since this is not a geometric operation, the {@code srcPt} | |
| * will equal the {@code dstPt}. | |
| * @param srcPt a {@code Point2D} that represents a point | |
| * in the source image | |
| * @param dstPt a {@code Point2D} that represents the location | |
| * in the destination | |
| * @return the {@code Point2D} 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} object associated | |
| * with this op. | |
| */ | |
| public final RenderingHints getRenderingHints() { | |
| return hints; | |
| } | |
| private 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 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); | |
| } | |
| } | |
| } | |
| } |