Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.pdfbox.pdmodel.graphics.xobject; import java.awt.AlphaComposite; import java.awt.Color; import java.awt.Graphics2D; import java.awt.Transparency; import java.awt.color.ColorSpace; import java.awt.image.ComponentColorModel; import java.awt.image.DataBuffer; import java.awt.image.DataBufferByte; import java.awt.image.BufferedImage; import java.awt.image.ColorModel; import java.awt.image.IndexColorModel; import java.awt.image.WritableRaster; import java.io.IOException; import java.io.OutputStream; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.pdfbox.cos.COSArray; import org.apache.pdfbox.cos.COSBase; import org.apache.pdfbox.cos.COSDictionary; import org.apache.pdfbox.cos.COSName; import org.apache.pdfbox.pdmodel.PDDocument; import org.apache.pdfbox.pdmodel.common.PDStream; import org.apache.pdfbox.pdmodel.common.function.PDFunction; import org.apache.pdfbox.pdmodel.graphics.color.PDColorSpace; import org.apache.pdfbox.pdmodel.graphics.color.PDDeviceGray; import org.apache.pdfbox.pdmodel.graphics.color.PDDeviceRGB; import org.apache.pdfbox.pdmodel.graphics.color.PDICCBased; import org.apache.pdfbox.pdmodel.graphics.color.PDIndexed; import org.apache.pdfbox.pdmodel.graphics.color.PDSeparation; import org.apache.pdfbox.util.ImageIOUtil; /** * This class contains a PixelMap Image. * @author <a href="mailto:ben@benlitchfield.com">Ben Litchfield</a> * @author mathiak * @version $Revision: 1.10 $ */ public class PDPixelMap extends PDXObjectImage { /** * Log instance. */ private static final Log LOG = LogFactory.getLog(PDPixelMap.class); private BufferedImage image = null; private static final String PNG = "png"; /** * Standard constructor. Basically does nothing. * @param pdStream The stream that holds the pixel map. */ public PDPixelMap(PDStream pdStream) { super(pdStream, PNG); } /** * Construct a pixel map image from an AWT image. * * * @param doc The PDF document to embed the image in. * @param bi The image to read data from. * * @throws IOException If there is an error while embedding this image. */ public PDPixelMap(PDDocument doc, BufferedImage bi) throws IOException { super(doc, PNG); createImageStream(doc, bi); } private void createImageStream(PDDocument doc, BufferedImage bi) throws IOException { BufferedImage alphaImage = null; BufferedImage rgbImage = null; int width = bi.getWidth(); int height = bi.getHeight(); if (bi.getColorModel().hasAlpha()) { // extract the alpha information WritableRaster alphaRaster = bi.getAlphaRaster(); ColorModel cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_GRAY), false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE); alphaImage = new BufferedImage(cm, alphaRaster, false, null); // create a RGB image without alpha rgbImage = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR); Graphics2D g = rgbImage.createGraphics(); g.setComposite(AlphaComposite.Src); g.drawImage(bi, 0, 0, null); } else { rgbImage = bi; } java.io.OutputStream os = null; try { int numberOfComponents = rgbImage.getColorModel().getNumComponents(); if (numberOfComponents == 3) { setColorSpace(PDDeviceRGB.INSTANCE); } else { if (numberOfComponents == 1) { setColorSpace(new PDDeviceGray()); } else { throw new IllegalStateException(); } } byte[] outData = new byte[width * height * numberOfComponents]; rgbImage.getData().getDataElements(0, 0, width, height, outData); // add FlateDecode compression getPDStream().addCompression(); os = getCOSStream().createUnfilteredStream(); os.write(outData); COSDictionary dic = getCOSStream(); dic.setItem(COSName.FILTER, COSName.FLATE_DECODE); dic.setItem(COSName.SUBTYPE, COSName.IMAGE); dic.setItem(COSName.TYPE, COSName.XOBJECT); if (alphaImage != null) { PDPixelMap smask = new PDPixelMap(doc, alphaImage); dic.setItem(COSName.SMASK, smask); } setBitsPerComponent(8); setHeight(height); setWidth(width); } finally { os.close(); } } /** * Returns a {@link java.awt.image.BufferedImage} of the COSStream * set in the constructor or null if the COSStream could not be encoded. * * @return {@inheritDoc} * * @throws IOException {@inheritDoc} */ public BufferedImage getRGBImage() throws IOException { if (image != null) { return image; } try { int width = getWidth(); int height = getHeight(); int bpc = getBitsPerComponent(); byte[] array = getPDStream().getByteArray(); if (array.length == 0) { LOG.error("Something went wrong ... the pixelmap doesn't contain any data."); return null; } // Get the ColorModel right PDColorSpace colorspace = getColorSpace(); if (colorspace == null) { LOG.error("getColorSpace() returned NULL. Predictor = " + getPredictor()); return null; } ColorModel cm = null; if (colorspace instanceof PDIndexed) { PDIndexed csIndexed = (PDIndexed) colorspace; // the base color space uses 8 bit per component, as the indexed color values // of an indexed color space are always in a range from 0 to 255 ColorModel baseColorModel = csIndexed.getBaseColorSpace().createColorModel(8); // number of possible color values in the target color space int numberOfColorValues = 1 << bpc; // number of indexed color values int highValue = csIndexed.getHighValue(); // choose the correct size, sometimes there are more indexed values than needed // and sometimes there are fewer indexed value than possible int size = Math.min(numberOfColorValues - 1, highValue); byte[] index = csIndexed.getLookupData(); boolean hasAlpha = baseColorModel.hasAlpha(); COSBase maskArray = getMask(); if (baseColorModel.getTransferType() != DataBuffer.TYPE_BYTE) { throw new IOException("Not implemented"); } // the IndexColorModel uses RGB-based color values // which leads to 3 color components and a optional alpha channel int numberOfComponents = 3 + (hasAlpha ? 1 : 0); int buffersize = (size + 1) * numberOfComponents; byte[] colorValues = new byte[buffersize]; byte[] inData = new byte[baseColorModel.getNumComponents()]; int bufferIndex = 0; for (int i = 0; i <= size; i++) { System.arraycopy(index, i * inData.length, inData, 0, inData.length); // convert the indexed color values to RGB colorValues[bufferIndex] = (byte) baseColorModel.getRed(inData); colorValues[bufferIndex + 1] = (byte) baseColorModel.getGreen(inData); colorValues[bufferIndex + 2] = (byte) baseColorModel.getBlue(inData); if (hasAlpha) { colorValues[bufferIndex + 3] = (byte) baseColorModel.getAlpha(inData); } bufferIndex += numberOfComponents; } if (maskArray != null && maskArray instanceof COSArray) { cm = new IndexColorModel(bpc, size + 1, colorValues, 0, hasAlpha, ((COSArray) maskArray).getInt(0)); } else { cm = new IndexColorModel(bpc, size + 1, colorValues, 0, hasAlpha); } } else if (colorspace instanceof PDSeparation) { PDSeparation csSeparation = (PDSeparation) colorspace; int numberOfComponents = csSeparation.getAlternateColorSpace().getNumberOfComponents(); PDFunction tintTransformFunc = csSeparation.getTintTransform(); COSArray decode = getDecode(); // we have to invert the tint-values, // if the Decode array exists and consists of (1,0) boolean invert = decode != null && decode.getInt(0) == 1; // TODO add interpolation for other decode values then 1,0 int maxValue = (int) Math.pow(2, bpc) - 1; // destination array byte[] mappedData = new byte[width * height * numberOfComponents]; int rowLength = width * numberOfComponents; float[] input = new float[1]; for (int i = 0; i < height; i++) { int rowOffset = i * rowLength; for (int j = 0; j < width; j++) { // scale tint values to a range of 0...1 int value = (array[i * width + j] + 256) % 256; if (invert) { input[0] = 1 - (value / maxValue); } else { input[0] = value / maxValue; } float[] mappedColor = tintTransformFunc.eval(input); int columnOffset = j * numberOfComponents; for (int k = 0; k < numberOfComponents; k++) { // redo scaling for every single color value float mappedValue = mappedColor[k]; mappedData[rowOffset + columnOffset + k] = (byte) (mappedValue * maxValue); } } } array = mappedData; cm = colorspace.createColorModel(bpc); } else if (bpc == 1) { byte[] map = null; if (colorspace instanceof PDDeviceGray) { COSArray decode = getDecode(); // we have to invert the b/w-values, // if the Decode array exists and consists of (1,0) if (decode != null && decode.getInt(0) == 1) { map = new byte[] { (byte) 0xff }; } else { map = new byte[] { (byte) 0x00, (byte) 0xff }; } } else if (colorspace instanceof PDICCBased) { if (((PDICCBased) colorspace).getNumberOfComponents() == 1) { map = new byte[] { (byte) 0xff }; } else { map = new byte[] { (byte) 0x00, (byte) 0xff }; } } else { map = new byte[] { (byte) 0x00, (byte) 0xff }; } cm = new IndexColorModel(bpc, map.length, map, map, map, Transparency.OPAQUE); } else { if (colorspace instanceof PDICCBased) { if (((PDICCBased) colorspace).getNumberOfComponents() == 1) { byte[] map = new byte[] { (byte) 0xff }; cm = new IndexColorModel(bpc, 1, map, map, map, Transparency.OPAQUE); } else { cm = colorspace.createColorModel(bpc); } } else { cm = colorspace.createColorModel(bpc); } } LOG.debug("ColorModel: " + cm.toString()); WritableRaster raster = cm.createCompatibleWritableRaster(width, height); DataBufferByte buffer = (DataBufferByte) raster.getDataBuffer(); byte[] bufferData = buffer.getData(); System.arraycopy(array, 0, bufferData, 0, (array.length < bufferData.length ? array.length : bufferData.length)); image = new BufferedImage(cm, raster, false, null); // If there is a 'soft mask' image then we use that as a transparency mask. PDXObjectImage smask = getSMaskImage(); if (smask != null) { BufferedImage smaskBI = smask.getRGBImage(); COSArray decodeArray = smask.getDecode(); CompositeImage compositeImage = new CompositeImage(image, smaskBI); BufferedImage rgbImage = compositeImage.createMaskedImage(decodeArray); return rgbImage; } else if (getImageMask()) { BufferedImage stencilMask = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB); Graphics2D graphics = (Graphics2D) stencilMask.getGraphics(); if (getStencilColor() != null) { graphics.setColor(getStencilColor().getJavaColor()); } else { // this might happen when using ExractImages, see PDFBOX-1145 LOG.debug("no stencil color for PixelMap found, using Color.BLACK instead."); graphics.setColor(Color.BLACK); } graphics.fillRect(0, 0, width, height); // assume default values ([0,1]) for the DecodeArray // TODO DecodeArray == [1,0] graphics.setComposite(AlphaComposite.DstIn); graphics.drawImage(image, null, 0, 0); return stencilMask; } else { // if there is no mask, use the unaltered image. return image; } } catch (Exception exception) { LOG.error(exception, exception); //A NULL return is caught in pagedrawer.Invoke.process() so don't re-throw. //Returning the NULL falls through to Phillip Koch's TODO section. return null; } } /** * Writes the image as .png. * * {@inheritDoc} */ public void write2OutputStream(OutputStream out) throws IOException { getRGBImage(); if (image != null) { ImageIOUtil.writeImage(image, PNG, out); } } /** * DecodeParms is an optional parameter for filters. * * It is provided if any of the filters has nondefault parameters. If there * is only one filter it is a dictionary, if there are multiple filters it * is an array with an entry for each filter. An array entry can hold a null * value if only the default values are used or a dictionary with * parameters. * * @return The decoding parameters. * */ public COSDictionary getDecodeParams() { COSBase decodeParms = getCOSStream().getDictionaryObject(COSName.DECODE_PARMS); if (decodeParms != null) { if (decodeParms instanceof COSDictionary) { return (COSDictionary) decodeParms; } else if (decodeParms instanceof COSArray) { // not implemented yet, which index should we use? return null;//(COSDictionary)((COSArray)decodeParms).get(0); } else { return null; } } return null; } /** * A code that selects the predictor algorithm. * * <ul> * <li>1 No prediction (the default value) * <li>2 TIFF Predictor 2 * <li>10 PNG prediction (on encoding, PNG None on all rows) * <li>11 PNG prediction (on encoding, PNG Sub on all rows) * <li>12 PNG prediction (on encoding, PNG Up on all rows) * <li>13 PNG prediction (on encoding, PNG Average on all rows) * <li>14 PNG prediction (on encoding, PNG Path on all rows) * <li>15 PNG prediction (on encoding, PNG optimum) * </ul> * * Default value: 1. * * @return predictor algorithm code */ public int getPredictor() { COSDictionary decodeParms = getDecodeParams(); if (decodeParms != null) { int i = decodeParms.getInt(COSName.PREDICTOR); if (i != -1) { return i; } } return 1; } }