Java tutorial
/* * * This file is part of the iText (R) project. Copyright (c) 1998-2019 iText Group NV * Authors: Bruno Lowagie, Paulo Soares, et al. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License version 3 * as published by the Free Software Foundation with the addition of the * following permission added to Section 15 as permitted in Section 7(a): * FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY * ITEXT GROUP. ITEXT GROUP DISCLAIMS THE WARRANTY OF NON INFRINGEMENT * OF THIRD PARTY RIGHTS * * This program 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 Affero General Public License for more details. * You should have received a copy of the GNU Affero General Public License * along with this program; if not, see http://www.gnu.org/licenses or write to * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA, 02110-1301 USA, or download the license from the following URL: * http://itextpdf.com/terms-of-use/ * * The interactive user interfaces in modified source and object code versions * of this program must display Appropriate Legal Notices, as required under * Section 5 of the GNU Affero General Public License. * * In accordance with Section 7(b) of the GNU Affero General Public License, * a covered work must retain the producer line in every PDF that is created * or manipulated using iText. * * You can be released from the requirements of the license by purchasing * a commercial license. Buying such a license is mandatory as soon as you * develop commercial activities involving the iText software without * disclosing the source code of your own applications. * These activities include: offering paid services to customers as an ASP, * serving PDFs on the fly in a web application, shipping iText with a closed * source product. * * For more information, please contact iText Software Corp. at this * address: sales@itextpdf.com */ package com.itextpdf.text; import com.itextpdf.awt.PdfGraphics2D; import com.itextpdf.text.api.Indentable; import com.itextpdf.text.api.Spaceable; import com.itextpdf.text.error_messages.MessageLocalization; import com.itextpdf.text.io.RandomAccessSourceFactory; import com.itextpdf.text.pdf.ICC_Profile; import com.itextpdf.text.pdf.PRIndirectReference; import com.itextpdf.text.pdf.PdfArray; import com.itextpdf.text.pdf.PdfContentByte; import com.itextpdf.text.pdf.PdfDictionary; import com.itextpdf.text.pdf.PdfIndirectReference; import com.itextpdf.text.pdf.PdfName; import com.itextpdf.text.pdf.PdfNumber; import com.itextpdf.text.pdf.PdfOCG; import com.itextpdf.text.pdf.PdfObject; import com.itextpdf.text.pdf.PdfReader; import com.itextpdf.text.pdf.PdfStream; import com.itextpdf.text.pdf.PdfString; import com.itextpdf.text.pdf.PdfTemplate; import com.itextpdf.text.pdf.PdfWriter; import com.itextpdf.text.pdf.RandomAccessFileOrArray; import com.itextpdf.text.pdf.codec.BmpImage; import com.itextpdf.text.pdf.codec.CCITTG4Encoder; import com.itextpdf.text.pdf.codec.GifImage; import com.itextpdf.text.pdf.codec.JBIG2Image; import com.itextpdf.text.pdf.codec.PngImage; import com.itextpdf.text.pdf.codec.TiffImage; import com.itextpdf.text.pdf.interfaces.IAccessibleElement; import com.itextpdf.text.pdf.interfaces.IAlternateDescription; import java.io.IOException; import java.io.InputStream; import java.lang.reflect.Constructor; import java.net.MalformedURLException; import java.net.URL; import java.util.HashMap; /** * An <CODE>Image</CODE> is the representation of a graphic element (JPEG, PNG * or GIF) that has to be inserted into the document * * @see Element * @see Rectangle */ public abstract class Image extends Rectangle implements Indentable, Spaceable, IAccessibleElement, IAlternateDescription { // static final membervariables /** this is a kind of image alignment. */ public static final int DEFAULT = 0; /** this is a kind of image alignment. */ public static final int RIGHT = 2; /** this is a kind of image alignment. */ public static final int LEFT = 0; /** this is a kind of image alignment. */ public static final int MIDDLE = 1; /** this is a kind of image alignment. */ public static final int TEXTWRAP = 4; /** this is a kind of image alignment. */ public static final int UNDERLYING = 8; /** This represents a coordinate in the transformation matrix. */ public static final int AX = 0; /** This represents a coordinate in the transformation matrix. */ public static final int AY = 1; /** This represents a coordinate in the transformation matrix. */ public static final int BX = 2; /** This represents a coordinate in the transformation matrix. */ public static final int BY = 3; /** This represents a coordinate in the transformation matrix. */ public static final int CX = 4; /** This represents a coordinate in the transformation matrix. */ public static final int CY = 5; /** This represents a coordinate in the transformation matrix. */ public static final int DX = 6; /** This represents a coordinate in the transformation matrix. */ public static final int DY = 7; /** type of image */ public static final int ORIGINAL_NONE = 0; /** type of image */ public static final int ORIGINAL_JPEG = 1; /** type of image */ public static final int ORIGINAL_PNG = 2; /** type of image */ public static final int ORIGINAL_GIF = 3; /** type of image */ public static final int ORIGINAL_BMP = 4; /** type of image */ public static final int ORIGINAL_TIFF = 5; /** type of image */ public static final int ORIGINAL_WMF = 6; /** type of image */ public static final int ORIGINAL_PS = 7; /** type of image */ public static final int ORIGINAL_JPEG2000 = 8; /** * type of image * @since 2.1.5 */ public static final int ORIGINAL_JBIG2 = 9; // member variables /** The image type. */ protected int type; /** The URL of the image. */ protected URL url; /** The raw data of the image. */ protected byte rawData[]; /** The bits per component of the raw image. It also flags a CCITT image. */ protected int bpc = 1; /** The template to be treated as an image. */ protected PdfTemplate template[] = new PdfTemplate[1]; /** The alignment of the Image. */ protected int alignment; /** Text that can be shown instead of the image. */ protected String alt; /** This is the absolute X-position of the image. */ protected float absoluteX = Float.NaN; /** This is the absolute Y-position of the image. */ protected float absoluteY = Float.NaN; /** This is the width of the image without rotation. */ protected float plainWidth; /** This is the width of the image without rotation. */ protected float plainHeight; /** This is the scaled width of the image taking rotation into account. */ protected float scaledWidth; /** This is the original height of the image taking rotation into account. */ protected float scaledHeight; /** * The compression level of the content streams. * @since 2.1.3 */ protected int compressionLevel = PdfStream.DEFAULT_COMPRESSION; /** an iText attributed unique id for this image. */ protected Long mySerialId = getSerialId(); protected PdfName role = PdfName.FIGURE; protected HashMap<PdfName, PdfObject> accessibleAttributes = null; private AccessibleElementId id = null; // image from file or URL /** * Constructs an <CODE>Image</CODE> -object, using an <VAR>url </VAR>. * * @param url * the <CODE>URL</CODE> where the image can be found. */ public Image(final URL url) { super(0, 0); this.url = url; this.alignment = DEFAULT; rotationRadians = 0; } public static Image getInstance(final URL url) throws BadElementException, MalformedURLException, IOException { return Image.getInstance(url, false); } /** * Gets an instance of an Image. * * @param url * an URL * @return an Image * @throws BadElementException * @throws MalformedURLException * @throws IOException */ public static Image getInstance(final URL url, boolean recoverFromImageError) throws BadElementException, MalformedURLException, IOException { InputStream is = null; RandomAccessSourceFactory randomAccessSourceFactory = new RandomAccessSourceFactory(); try { is = url.openStream(); int c1 = is.read(); int c2 = is.read(); int c3 = is.read(); int c4 = is.read(); // jbig2 int c5 = is.read(); int c6 = is.read(); int c7 = is.read(); int c8 = is.read(); is.close(); is = null; if (c1 == 'G' && c2 == 'I' && c3 == 'F') { GifImage gif = new GifImage(url); Image img = gif.getImage(1); return img; } if (c1 == 0xFF && c2 == 0xD8) { return new Jpeg(url); } if (c1 == 0x00 && c2 == 0x00 && c3 == 0x00 && c4 == 0x0c) { return new Jpeg2000(url); } if (c1 == 0xff && c2 == 0x4f && c3 == 0xff && c4 == 0x51) { return new Jpeg2000(url); } if (c1 == PngImage.PNGID[0] && c2 == PngImage.PNGID[1] && c3 == PngImage.PNGID[2] && c4 == PngImage.PNGID[3]) { return PngImage.getImage(url); } if (c1 == 0xD7 && c2 == 0xCD) { return new ImgWMF(url); } if (c1 == 'B' && c2 == 'M') { return BmpImage.getImage(url); } if (c1 == 'M' && c2 == 'M' && c3 == 0 && c4 == 42 || c1 == 'I' && c2 == 'I' && c3 == 42 && c4 == 0) { RandomAccessFileOrArray ra = null; try { if (url.getProtocol().equals("file")) { String file = url.getFile(); file = Utilities.unEscapeURL(file); ra = new RandomAccessFileOrArray(randomAccessSourceFactory.createBestSource(file)); } else ra = new RandomAccessFileOrArray(randomAccessSourceFactory.createSource(url)); Image img = TiffImage.getTiffImage(ra, 1); img.url = url; return img; } catch (RuntimeException e) { if (recoverFromImageError) { // reruns the getTiffImage() with several error recovering workarounds in place // not guaranteed to work with every TIFF Image img = TiffImage.getTiffImage(ra, recoverFromImageError, 1); img.url = url; return img; } throw e; } finally { if (ra != null) ra.close(); } } if (c1 == 0x97 && c2 == 'J' && c3 == 'B' && c4 == '2' && c5 == '\r' && c6 == '\n' && c7 == 0x1a && c8 == '\n') { RandomAccessFileOrArray ra = null; try { if (url.getProtocol().equals("file")) { String file = url.getFile(); file = Utilities.unEscapeURL(file); ra = new RandomAccessFileOrArray(randomAccessSourceFactory.createBestSource(file)); } else ra = new RandomAccessFileOrArray(randomAccessSourceFactory.createSource(url)); Image img = JBIG2Image.getJbig2Image(ra, 1); img.url = url; return img; } finally { if (ra != null) ra.close(); } } throw new IOException(MessageLocalization.getComposedMessage("unknown.image.format", url.toString())); } finally { if (is != null) { is.close(); } } } /** * Gets an instance of an Image. * * @param filename * a filename * @return an object of type <CODE>Gif</CODE>,<CODE>Jpeg</CODE> or * <CODE>Png</CODE> * @throws BadElementException * @throws MalformedURLException * @throws IOException */ public static Image getInstance(final String filename) throws BadElementException, MalformedURLException, IOException { return getInstance(Utilities.toURL(filename)); } public static Image getInstance(final String filename, boolean recoverFromImageError) throws IOException, BadElementException { return getInstance(Utilities.toURL(filename), recoverFromImageError); } public static Image getInstance(final byte imgb[]) throws BadElementException, MalformedURLException, IOException { return getInstance(imgb, false); } /** * gets an instance of an Image * * @param imgb * raw image date * @return an Image object * @throws BadElementException * @throws MalformedURLException * @throws IOException */ public static Image getInstance(final byte imgb[], boolean recoverFromImageError) throws BadElementException, MalformedURLException, IOException { InputStream is = null; RandomAccessSourceFactory randomAccessSourceFactory = new RandomAccessSourceFactory(); try { is = new java.io.ByteArrayInputStream(imgb); int c1 = is.read(); int c2 = is.read(); int c3 = is.read(); int c4 = is.read(); is.close(); is = null; if (c1 == 'G' && c2 == 'I' && c3 == 'F') { GifImage gif = new GifImage(imgb); return gif.getImage(1); } if (c1 == 0xFF && c2 == 0xD8) { return new Jpeg(imgb); } if (c1 == 0x00 && c2 == 0x00 && c3 == 0x00 && c4 == 0x0c) { return new Jpeg2000(imgb); } if (c1 == 0xff && c2 == 0x4f && c3 == 0xff && c4 == 0x51) { return new Jpeg2000(imgb); } if (c1 == PngImage.PNGID[0] && c2 == PngImage.PNGID[1] && c3 == PngImage.PNGID[2] && c4 == PngImage.PNGID[3]) { return PngImage.getImage(imgb); } if (c1 == 0xD7 && c2 == 0xCD) { return new ImgWMF(imgb); } if (c1 == 'B' && c2 == 'M') { return BmpImage.getImage(imgb); } if (c1 == 'M' && c2 == 'M' && c3 == 0 && c4 == 42 || c1 == 'I' && c2 == 'I' && c3 == 42 && c4 == 0) { RandomAccessFileOrArray ra = null; try { ra = new RandomAccessFileOrArray(randomAccessSourceFactory.createSource(imgb)); Image img = TiffImage.getTiffImage(ra, 1); if (img.getOriginalData() == null) img.setOriginalData(imgb); return img; } catch (RuntimeException e) { if (recoverFromImageError) { // reruns the getTiffImage() with several error recovering workarounds in place // not guaranteed to work with every TIFF Image img = TiffImage.getTiffImage(ra, recoverFromImageError, 1); if (img.getOriginalData() == null) img.setOriginalData(imgb); return img; } throw e; } finally { if (ra != null) ra.close(); } } if (c1 == 0x97 && c2 == 'J' && c3 == 'B' && c4 == '2') { is = new java.io.ByteArrayInputStream(imgb); is.skip(4); int c5 = is.read(); int c6 = is.read(); int c7 = is.read(); int c8 = is.read(); is.close(); if (c5 == '\r' && c6 == '\n' && c7 == 0x1a && c8 == '\n') { // a jbig2 file with a file header. the header is the only way we know here. // embedded jbig2s don't have a header, have to create them by explicit use of Jbig2Image? // nkerr, 2008-12-05 see also the getInstance(URL) RandomAccessFileOrArray ra = null; try { ra = new RandomAccessFileOrArray(randomAccessSourceFactory.createSource(imgb)); Image img = JBIG2Image.getJbig2Image(ra, 1); if (img.getOriginalData() == null) img.setOriginalData(imgb); return img; } finally { if (ra != null) ra.close(); } } } throw new IOException( MessageLocalization.getComposedMessage("the.byte.array.is.not.a.recognized.imageformat")); } finally { if (is != null) { is.close(); } } } /** * Gets an instance of an Image in raw mode. * * @param width * the width of the image in pixels * @param height * the height of the image in pixels * @param components * 1,3 or 4 for GrayScale, RGB and CMYK * @param data * the image data * @param bpc * bits per component * @return an object of type <CODE>ImgRaw</CODE> * @throws BadElementException * on error */ public static Image getInstance(final int width, final int height, final int components, final int bpc, final byte data[]) throws BadElementException { return Image.getInstance(width, height, components, bpc, data, null); } /** * Creates a JBIG2 Image. * @param width the width of the image * @param height the height of the image * @param data the raw image data * @param globals JBIG2 globals * @return the Image * @since 2.1.5 */ public static Image getInstance(final int width, final int height, final byte[] data, final byte[] globals) { return new ImgJBIG2(width, height, data, globals); } /** * Creates an Image with CCITT G3 or G4 compression. It assumes that the * data bytes are already compressed. * * @param width * the exact width of the image * @param height * the exact height of the image * @param reverseBits * reverses the bits in <code>data</code>. Bit 0 is swapped * with bit 7 and so on * @param typeCCITT * the type of compression in <code>data</code>. It can be * CCITTG4, CCITTG31D, CCITTG32D * @param parameters * parameters associated with this stream. Possible values are * CCITT_BLACKIS1, CCITT_ENCODEDBYTEALIGN, CCITT_ENDOFLINE and * CCITT_ENDOFBLOCK or a combination of them * @param data * the image data * @return an Image object * @throws BadElementException * on error */ public static Image getInstance(final int width, final int height, final boolean reverseBits, final int typeCCITT, final int parameters, final byte[] data) throws BadElementException { return Image.getInstance(width, height, reverseBits, typeCCITT, parameters, data, null); } /** * Creates an Image with CCITT G3 or G4 compression. It assumes that the * data bytes are already compressed. * * @param width * the exact width of the image * @param height * the exact height of the image * @param reverseBits * reverses the bits in <code>data</code>. Bit 0 is swapped * with bit 7 and so on * @param typeCCITT * the type of compression in <code>data</code>. It can be * CCITTG4, CCITTG31D, CCITTG32D * @param parameters * parameters associated with this stream. Possible values are * CCITT_BLACKIS1, CCITT_ENCODEDBYTEALIGN, CCITT_ENDOFLINE and * CCITT_ENDOFBLOCK or a combination of them * @param data * the image data * @param transparency * transparency information in the Mask format of the image * dictionary * @return an Image object * @throws BadElementException * on error */ public static Image getInstance(final int width, final int height, final boolean reverseBits, final int typeCCITT, final int parameters, final byte[] data, final int transparency[]) throws BadElementException { if (transparency != null && transparency.length != 2) throw new BadElementException(MessageLocalization .getComposedMessage("transparency.length.must.be.equal.to.2.with.ccitt.images")); Image img = new ImgCCITT(width, height, reverseBits, typeCCITT, parameters, data); img.transparency = transparency; return img; } /** * Gets an instance of an Image in raw mode. * * @param width * the width of the image in pixels * @param height * the height of the image in pixels * @param components * 1,3 or 4 for GrayScale, RGB and CMYK * @param data * the image data * @param bpc * bits per component * @param transparency * transparency information in the Mask format of the image * dictionary * @return an object of type <CODE>ImgRaw</CODE> * @throws BadElementException * on error */ public static Image getInstance(final int width, final int height, final int components, final int bpc, final byte data[], final int transparency[]) throws BadElementException { if (transparency != null && transparency.length != components * 2) throw new BadElementException( MessageLocalization.getComposedMessage("transparency.length.must.be.equal.to.componentes.2")); if (components == 1 && bpc == 1) { byte g4[] = CCITTG4Encoder.compress(data, width, height); return Image.getInstance(width, height, false, Image.CCITTG4, Image.CCITT_BLACKIS1, g4, transparency); } Image img = new ImgRaw(width, height, components, bpc, data); img.transparency = transparency; return img; } // images from a PdfTemplate /** * gets an instance of an Image * * @param template * a PdfTemplate that has to be wrapped in an Image object * @return an Image object * @throws BadElementException */ public static Image getInstance(final PdfTemplate template) throws BadElementException { return new ImgTemplate(template); } // image from indirect reference /** * Holds value of property directReference. * An image is embedded into a PDF as an Image XObject. * This object is referenced by a PdfIndirectReference object. */ private PdfIndirectReference directReference; /** * Getter for property directReference. * @return Value of property directReference. */ public PdfIndirectReference getDirectReference() { return this.directReference; } /** * Setter for property directReference. * @param directReference New value of property directReference. */ public void setDirectReference(final PdfIndirectReference directReference) { this.directReference = directReference; } /** * Reuses an existing image. * @param ref the reference to the image dictionary * @throws BadElementException on error * @return the image */ public static Image getInstance(final PRIndirectReference ref) throws BadElementException { PdfDictionary dic = (PdfDictionary) PdfReader.getPdfObjectRelease(ref); int width = ((PdfNumber) PdfReader.getPdfObjectRelease(dic.get(PdfName.WIDTH))).intValue(); int height = ((PdfNumber) PdfReader.getPdfObjectRelease(dic.get(PdfName.HEIGHT))).intValue(); Image imask = null; PdfObject obj = dic.get(PdfName.SMASK); if (obj != null && obj.isIndirect()) { imask = getInstance((PRIndirectReference) obj); } else { obj = dic.get(PdfName.MASK); if (obj != null && obj.isIndirect()) { PdfObject obj2 = PdfReader.getPdfObjectRelease(obj); if (obj2 instanceof PdfDictionary) imask = getInstance((PRIndirectReference) obj); } } Image img = new ImgRaw(width, height, 1, 1, null); img.imageMask = imask; img.directReference = ref; return img; } // copy constructor /** * Constructs an <CODE>Image</CODE> -object, using an <VAR>url </VAR>. * * @param image * another Image object. */ protected Image(final Image image) { super(image); this.type = image.type; this.url = image.url; this.rawData = image.rawData; this.bpc = image.bpc; this.template = image.template; this.alignment = image.alignment; this.alt = image.alt; this.absoluteX = image.absoluteX; this.absoluteY = image.absoluteY; this.plainWidth = image.plainWidth; this.plainHeight = image.plainHeight; this.scaledWidth = image.scaledWidth; this.scaledHeight = image.scaledHeight; this.mySerialId = image.mySerialId; this.directReference = image.directReference; this.rotationRadians = image.rotationRadians; this.initialRotation = image.initialRotation; this.indentationLeft = image.indentationLeft; this.indentationRight = image.indentationRight; this.spacingBefore = image.spacingBefore; this.spacingAfter = image.spacingAfter; this.widthPercentage = image.widthPercentage; this.scaleToFitLineWhenOverflow = image.scaleToFitLineWhenOverflow; this.scaleToFitHeight = image.scaleToFitHeight; this.annotation = image.annotation; this.layer = image.layer; this.interpolation = image.interpolation; this.originalType = image.originalType; this.originalData = image.originalData; this.deflated = image.deflated; this.dpiX = image.dpiX; this.dpiY = image.dpiY; this.XYRatio = image.XYRatio; this.colorspace = image.colorspace; this.invert = image.invert; this.profile = image.profile; this.additional = image.additional; this.mask = image.mask; this.imageMask = image.imageMask; this.smask = image.smask; this.transparency = image.transparency; this.role = image.role; if (image.accessibleAttributes != null) this.accessibleAttributes = new HashMap<PdfName, PdfObject>(image.accessibleAttributes); setId(image.getId()); } /** * gets an instance of an Image * * @param image * an Image object * @return a new Image object */ public static Image getInstance(final Image image) { if (image == null) return null; try { Class<? extends Image> cs = image.getClass(); Constructor<? extends Image> constructor = cs.getDeclaredConstructor(new Class[] { Image.class }); return constructor.newInstance(new Object[] { image }); } catch (Exception e) { throw new ExceptionConverter(e); } } // implementation of the Element interface /** * Returns the type. * * @return a type */ @Override public int type() { return type; } /** * @see com.itextpdf.text.Element#isNestable() * @since iText 2.0.8 */ @Override public boolean isNestable() { return true; } // checking the type of Image /** * Returns <CODE>true</CODE> if the image is a <CODE>Jpeg</CODE> * -object. * * @return a <CODE>boolean</CODE> */ public boolean isJpeg() { return type == JPEG; } /** * Returns <CODE>true</CODE> if the image is a <CODE>ImgRaw</CODE> * -object. * * @return a <CODE>boolean</CODE> */ public boolean isImgRaw() { return type == IMGRAW; } /** * Returns <CODE>true</CODE> if the image is an <CODE>ImgTemplate</CODE> * -object. * * @return a <CODE>boolean</CODE> */ public boolean isImgTemplate() { return type == IMGTEMPLATE; } // getters and setters /** * Gets the <CODE>String</CODE> -representation of the reference to the * image. * * @return a <CODE>String</CODE> */ public URL getUrl() { return url; } /** * Sets the url of the image * * @param url * the url of the image */ public void setUrl(final URL url) { this.url = url; } /** * Gets the raw data for the image. * <P> * Remark: this only makes sense for Images of the type <CODE>RawImage * </CODE>. * * @return the raw data */ public byte[] getRawData() { return rawData; } /** * Gets the bpc for the image. * <P> * Remark: this only makes sense for Images of the type <CODE>RawImage * </CODE>. * * @return a bpc value */ public int getBpc() { return bpc; } /** * Gets the template to be used as an image. * <P> * Remark: this only makes sense for Images of the type <CODE>ImgTemplate * </CODE>. * * @return the template */ public PdfTemplate getTemplateData() { return template[0]; } /** * Sets data from a PdfTemplate * * @param template * the template with the content */ public void setTemplateData(final PdfTemplate template) { this.template[0] = template; } /** * Gets the alignment for the image. * * @return a value */ public int getAlignment() { return alignment; } /** * Sets the alignment for the image. * * @param alignment * the alignment */ public void setAlignment(final int alignment) { this.alignment = alignment; } /** * Gets the alternative text for the image. * * @return a <CODE>String</CODE> */ public String getAlt() { return alt; } /** * Sets the alternative information for the image. * * @param alt * the alternative information */ public void setAlt(final String alt) { this.alt = alt; setAccessibleAttribute(PdfName.ALT, new PdfString(alt)); } /** * Sets the absolute position of the <CODE>Image</CODE>. * * @param absoluteX * @param absoluteY */ public void setAbsolutePosition(final float absoluteX, final float absoluteY) { this.absoluteX = absoluteX; this.absoluteY = absoluteY; } /** * Checks if the <CODE>Images</CODE> has to be added at an absolute X * position. * * @return a boolean */ public boolean hasAbsoluteX() { return !Float.isNaN(absoluteX); } /** * Returns the absolute X position. * * @return a position */ public float getAbsoluteX() { return absoluteX; } /** * Checks if the <CODE>Images</CODE> has to be added at an absolute * position. * * @return a boolean */ public boolean hasAbsoluteY() { return !Float.isNaN(absoluteY); } /** * Returns the absolute Y position. * * @return a position */ public float getAbsoluteY() { return absoluteY; } // width and height /** * Gets the scaled width of the image. * * @return a value */ public float getScaledWidth() { return scaledWidth; } /** * Gets the scaled height of the image. * * @return a value */ public float getScaledHeight() { return scaledHeight; } /** * Gets the plain width of the image. * * @return a value */ public float getPlainWidth() { return plainWidth; } /** * Gets the plain height of the image. * * @return a value */ public float getPlainHeight() { return plainHeight; } /** * Scale the image to the dimensions of the rectangle * * @param rectangle dimensions to scale the Image */ public void scaleAbsolute(final Rectangle rectangle) { scaleAbsolute(rectangle.getWidth(), rectangle.getHeight()); } /** * Scale the image to an absolute width and an absolute height. * * @param newWidth * the new width * @param newHeight * the new height */ public void scaleAbsolute(final float newWidth, final float newHeight) { plainWidth = newWidth; plainHeight = newHeight; float[] matrix = matrix(); scaledWidth = matrix[DX] - matrix[CX]; scaledHeight = matrix[DY] - matrix[CY]; setWidthPercentage(0); } /** * Scale the image to an absolute width. * * @param newWidth * the new width */ public void scaleAbsoluteWidth(final float newWidth) { plainWidth = newWidth; float[] matrix = matrix(); scaledWidth = matrix[DX] - matrix[CX]; scaledHeight = matrix[DY] - matrix[CY]; setWidthPercentage(0); } /** * Scale the image to an absolute height. * * @param newHeight * the new height */ public void scaleAbsoluteHeight(final float newHeight) { plainHeight = newHeight; float[] matrix = matrix(); scaledWidth = matrix[DX] - matrix[CX]; scaledHeight = matrix[DY] - matrix[CY]; setWidthPercentage(0); } /** * Scale the image to a certain percentage. * * @param percent * the scaling percentage */ public void scalePercent(final float percent) { scalePercent(percent, percent); } /** * Scale the width and height of an image to a certain percentage. * * @param percentX * the scaling percentage of the width * @param percentY * the scaling percentage of the height */ public void scalePercent(final float percentX, final float percentY) { plainWidth = getWidth() * percentX / 100f; plainHeight = getHeight() * percentY / 100f; float[] matrix = matrix(); scaledWidth = matrix[DX] - matrix[CX]; scaledHeight = matrix[DY] - matrix[CY]; setWidthPercentage(0); } /** * Scales the images to the dimensions of the rectangle. * * @param rectangle the dimensions to fit */ public void scaleToFit(final Rectangle rectangle) { scaleToFit(rectangle.getWidth(), rectangle.getHeight()); } /** * Scales the image so that it fits a certain width and height. * * @param fitWidth * the width to fit * @param fitHeight * the height to fit */ public void scaleToFit(final float fitWidth, final float fitHeight) { scalePercent(100); float percentX = fitWidth * 100 / getScaledWidth(); float percentY = fitHeight * 100 / getScaledHeight(); scalePercent(percentX < percentY ? percentX : percentY); setWidthPercentage(0); } /** * Returns the transformation matrix of the image. * * @return an array [AX, AY, BX, BY, CX, CY, DX, DY] */ public float[] matrix() { return matrix(1); } /** * Returns the transformation matrix of the image. * * @return an array [AX, AY, BX, BY, CX, CY, DX, DY] */ public float[] matrix(float scalePercentage) { float[] matrix = new float[8]; float cosX = (float) Math.cos(rotationRadians); float sinX = (float) Math.sin(rotationRadians); matrix[AX] = plainWidth * cosX * scalePercentage; matrix[AY] = plainWidth * sinX * scalePercentage; matrix[BX] = -plainHeight * sinX * scalePercentage; matrix[BY] = plainHeight * cosX * scalePercentage; if (rotationRadians < Math.PI / 2f) { matrix[CX] = matrix[BX]; matrix[CY] = 0; matrix[DX] = matrix[AX]; matrix[DY] = matrix[AY] + matrix[BY]; } else if (rotationRadians < Math.PI) { matrix[CX] = matrix[AX] + matrix[BX]; matrix[CY] = matrix[BY]; matrix[DX] = 0; matrix[DY] = matrix[AY]; } else if (rotationRadians < Math.PI * 1.5f) { matrix[CX] = matrix[AX]; matrix[CY] = matrix[AY] + matrix[BY]; matrix[DX] = matrix[BX]; matrix[DY] = 0; } else { matrix[CX] = 0; matrix[CY] = matrix[AY]; matrix[DX] = matrix[AX] + matrix[BX]; matrix[DY] = matrix[BY]; } return matrix; } // serial stamping /** a static that is used for attributing a unique id to each image. */ static long serialId = 0; /** Creates a new serial id. * @return the new serialId */ static protected synchronized Long getSerialId() { ++serialId; return Long.valueOf(serialId); } /** * Returns a serial id for the Image (reuse the same image more than once) * * @return a serialId */ public Long getMySerialId() { return mySerialId; } // rotation, note that the superclass also has a rotation value. /** This is the rotation of the image in radians. */ protected float rotationRadians; /** Holds value of property initialRotation. */ private float initialRotation; /** * Gets the current image rotation in radians. * @return the current image rotation in radians */ public float getImageRotation() { double d = 2.0 * Math.PI; float rot = (float) ((rotationRadians - initialRotation) % d); if (rot < 0) { rot += d; } return rot; } /** * Sets the rotation of the image in radians. * * @param r * rotation in radians */ public void setRotation(final float r) { double d = 2.0 * Math.PI; rotationRadians = (float) ((r + initialRotation) % d); if (rotationRadians < 0) { rotationRadians += d; } float[] matrix = matrix(); scaledWidth = matrix[DX] - matrix[CX]; scaledHeight = matrix[DY] - matrix[CY]; } /** * Sets the rotation of the image in degrees. * * @param deg * rotation in degrees */ public void setRotationDegrees(final float deg) { double d = Math.PI; setRotation(deg / 180 * (float) d); } /** * Getter for property initialRotation. * @return Value of property initialRotation. */ public float getInitialRotation() { return this.initialRotation; } /** * Some image formats, like TIFF may present the images rotated that have * to be compensated. * @param initialRotation New value of property initialRotation. */ public void setInitialRotation(final float initialRotation) { float old_rot = rotationRadians - this.initialRotation; this.initialRotation = initialRotation; setRotation(old_rot); } // indentations /** the indentation to the left. */ protected float indentationLeft = 0; /** the indentation to the right. */ protected float indentationRight = 0; /** The spacing before the image. */ protected float spacingBefore; /** The spacing after the image. */ protected float spacingAfter; /** Padding top */ protected float paddingTop; /** * Gets the left indentation. * * @return the left indentation */ public float getIndentationLeft() { return indentationLeft; } /** * Sets the left indentation. * * @param f */ public void setIndentationLeft(final float f) { indentationLeft = f; } /** * Gets the right indentation. * * @return the right indentation */ public float getIndentationRight() { return indentationRight; } /** * Sets the right indentation. * * @param f */ public void setIndentationRight(final float f) { indentationRight = f; } /** * Gets the spacing before this image. * * @return the spacing */ public float getSpacingBefore() { return spacingBefore; } /** * Sets the spacing before this image. * * @param spacing * the new spacing */ public void setSpacingBefore(final float spacing) { this.spacingBefore = spacing; } /** * Gets the spacing before this image. * * @return the spacing */ public float getSpacingAfter() { return spacingAfter; } /** * Sets the spacing after this image. * * @param spacing * the new spacing */ public void setSpacingAfter(final float spacing) { this.spacingAfter = spacing; } public float getPaddingTop() { return paddingTop; } public void setPaddingTop(float paddingTop) { this.paddingTop = paddingTop; } // widthpercentage (for the moment only used in ColumnText) /** * Holds value of property widthPercentage. */ private float widthPercentage = 100; /** * Getter for property widthPercentage. * * @return Value of property widthPercentage. */ public float getWidthPercentage() { return this.widthPercentage; } /** * Setter for property widthPercentage. * * @param widthPercentage * New value of property widthPercentage. */ public void setWidthPercentage(final float widthPercentage) { this.widthPercentage = widthPercentage; } // scaling the image to the available width (or not) /** * Indicates if the image should be scaled to fit the line * when the image exceeds the available width. * @since iText 5.0.6 */ protected boolean scaleToFitLineWhenOverflow; /** * Gets the value of scaleToFitLineWhenOverflow. * @return true if the image size has to scale to the available width * @since iText 5.0.6 */ public boolean isScaleToFitLineWhenOverflow() { return scaleToFitLineWhenOverflow; } /** * Sets the value of scaleToFitLineWhenOverflow * @param scaleToFitLineWhenOverflow true if you want the image to scale to the available width * @since iText 5.0.6 */ public void setScaleToFitLineWhenOverflow(final boolean scaleToFitLineWhenOverflow) { this.scaleToFitLineWhenOverflow = scaleToFitLineWhenOverflow; } // scaling the image to the available height (or not) /** * Indicates if the image should be scaled to fit * when the image exceeds the available height. * @since iText 5.4.2 */ protected boolean scaleToFitHeight = true; /** * Gets the value of scaleToFitHeight. * @return true if the image size has to scale to the available height * @since iText 5.4.2 */ public boolean isScaleToFitHeight() { return scaleToFitHeight; } /** * Sets the value of scaleToFitHeight * @param scaleToFitHeight true if you want the image to scale to the available height * @since iText 5.4.2 */ public void setScaleToFitHeight(final boolean scaleToFitHeight) { this.scaleToFitHeight = scaleToFitHeight; } // annotation /** if the annotation is not null the image will be clickable. */ protected Annotation annotation = null; /** * Sets the annotation of this Image. * * @param annotation * the annotation */ public void setAnnotation(final Annotation annotation) { this.annotation = annotation; } /** * Gets the annotation. * * @return the annotation that is linked to this image */ public Annotation getAnnotation() { return annotation; } // Optional Content /** Optional Content layer to which we want this Image to belong. */ protected PdfOCG layer; /** * Gets the layer this image belongs to. * * @return the layer this image belongs to or <code>null</code> for no * layer defined */ public PdfOCG getLayer() { return layer; } /** * Sets the layer this image belongs to. * * @param layer * the layer this image belongs to */ public void setLayer(final PdfOCG layer) { this.layer = layer; } // interpolation /** Holds value of property interpolation. */ protected boolean interpolation; /** * Getter for property interpolation. * * @return Value of property interpolation. */ public boolean isInterpolation() { return interpolation; } /** * Sets the image interpolation. Image interpolation attempts to produce a * smooth transition between adjacent sample values. * * @param interpolation * New value of property interpolation. */ public void setInterpolation(final boolean interpolation) { this.interpolation = interpolation; } // original type and data /** Holds value of property originalType. */ protected int originalType = ORIGINAL_NONE; /** Holds value of property originalData. */ protected byte[] originalData; /** * Getter for property originalType. * * @return Value of property originalType. * */ public int getOriginalType() { return this.originalType; } /** * Setter for property originalType. * * @param originalType * New value of property originalType. * */ public void setOriginalType(final int originalType) { this.originalType = originalType; } /** * Getter for property originalData. * * @return Value of property originalData. * */ public byte[] getOriginalData() { return this.originalData; } /** * Setter for property originalData. * * @param originalData * New value of property originalData. * */ public void setOriginalData(final byte[] originalData) { this.originalData = originalData; } // the following values are only set for specific types of images. /** Holds value of property deflated. */ protected boolean deflated = false; /** * Getter for property deflated. * * @return Value of property deflated. * */ public boolean isDeflated() { return this.deflated; } /** * Setter for property deflated. * * @param deflated * New value of property deflated. */ public void setDeflated(final boolean deflated) { this.deflated = deflated; } // DPI info /** Holds value of property dpiX. */ protected int dpiX = 0; /** Holds value of property dpiY. */ protected int dpiY = 0; /** * Gets the dots-per-inch in the X direction. Returns 0 if not available. * * @return the dots-per-inch in the X direction */ public int getDpiX() { return dpiX; } /** * Gets the dots-per-inch in the Y direction. Returns 0 if not available. * * @return the dots-per-inch in the Y direction */ public int getDpiY() { return dpiY; } /** * Sets the dots per inch value * * @param dpiX * dpi for x coordinates * @param dpiY * dpi for y coordinates */ public void setDpi(final int dpiX, final int dpiY) { this.dpiX = dpiX; this.dpiY = dpiY; } // XY Ratio /** Holds value of property XYRatio. */ private float XYRatio = 0; /** * Gets the X/Y pixel dimensionless aspect ratio. * * @return the X/Y pixel dimensionless aspect ratio */ public float getXYRatio() { return this.XYRatio; } /** * Sets the X/Y pixel dimensionless aspect ratio. * * @param XYRatio * the X/Y pixel dimensionless aspect ratio */ public void setXYRatio(final float XYRatio) { this.XYRatio = XYRatio; } // color, colorspaces and transparency /** this is the colorspace of a jpeg-image. */ protected int colorspace = -1; /** * Gets the colorspace for the image. * <P> * Remark: this only makes sense for Images of the type <CODE>Jpeg</CODE>. * * @return a colorspace value */ public int getColorspace() { return colorspace; } protected int colortransform = 1; public void setColorTransform(int c) { colortransform = c; } public int getColorTransform() { return colortransform; } /** Image color inversion */ protected boolean invert = false; /** * Getter for the inverted value * * @return true if the image is inverted */ public boolean isInverted() { return invert; } /** * Sets inverted true or false * * @param invert * true or false */ public void setInverted(final boolean invert) { this.invert = invert; } /** ICC Profile attached */ protected ICC_Profile profile = null; /** * Tags this image with an ICC profile. * * @param profile * the profile */ public void tagICC(final ICC_Profile profile) { this.profile = profile; } /** * Checks is the image has an ICC profile. * * @return the ICC profile or <CODE>null</CODE> */ public boolean hasICCProfile() { return this.profile != null; } /** * Gets the images ICC profile. * * @return the ICC profile */ public ICC_Profile getICCProfile() { return profile; } /** a dictionary with additional information */ private PdfDictionary additional = null; /** * Getter for the dictionary with additional information. * * @return a PdfDictionary with additional information. */ public PdfDictionary getAdditional() { return this.additional; } /** * Sets the /Colorspace key. * * @param additional * a PdfDictionary with additional information. */ public void setAdditional(final PdfDictionary additional) { this.additional = additional; } /** * Replaces CalRGB and CalGray colorspaces with DeviceRGB and DeviceGray. */ public void simplifyColorspace() { if (additional == null) return; PdfArray value = additional.getAsArray(PdfName.COLORSPACE); if (value == null) return; PdfObject cs = simplifyColorspace(value); PdfObject newValue; if (cs.isName()) newValue = cs; else { newValue = value; PdfName first = value.getAsName(0); if (PdfName.INDEXED.equals(first)) { if (value.size() >= 2) { PdfArray second = value.getAsArray(1); if (second != null) { value.set(1, simplifyColorspace(second)); } } } } additional.put(PdfName.COLORSPACE, newValue); } /** * Gets a PDF Name from an array or returns the object that was passed. */ private PdfObject simplifyColorspace(final PdfArray obj) { if (obj == null) return obj; PdfName first = obj.getAsName(0); if (PdfName.CALGRAY.equals(first)) return PdfName.DEVICEGRAY; else if (PdfName.CALRGB.equals(first)) return PdfName.DEVICERGB; else return obj; } /** Is this image a mask? */ protected boolean mask = false; /** The image that serves as a mask for this image. */ protected Image imageMask; /** Holds value of property smask. */ private boolean smask; /** * Returns <CODE>true</CODE> if this <CODE>Image</CODE> is a mask. * * @return <CODE>true</CODE> if this <CODE>Image</CODE> is a mask */ public boolean isMask() { return mask; } /** * Make this <CODE>Image</CODE> a mask. * * @throws DocumentException * if this <CODE>Image</CODE> can not be a mask */ public void makeMask() throws DocumentException { if (!isMaskCandidate()) throw new DocumentException( MessageLocalization.getComposedMessage("this.image.can.not.be.an.image.mask")); mask = true; } /** * Returns <CODE>true</CODE> if this <CODE>Image</CODE> has the * requisites to be a mask. * * @return <CODE>true</CODE> if this <CODE>Image</CODE> can be a mask */ public boolean isMaskCandidate() { if (type == IMGRAW) { if (bpc > 0xff) return true; } return colorspace == 1; } /** * Gets the explicit masking. * * @return the explicit masking */ public Image getImageMask() { return imageMask; } /** * Sets the explicit masking. * * @param mask * the mask to be applied * @throws DocumentException * on error */ public void setImageMask(final Image mask) throws DocumentException { if (this.mask) throw new DocumentException( MessageLocalization.getComposedMessage("an.image.mask.cannot.contain.another.image.mask")); if (!mask.mask) throw new DocumentException( MessageLocalization.getComposedMessage("the.image.mask.is.not.a.mask.did.you.do.makemask")); imageMask = mask; smask = mask.bpc > 1 && mask.bpc <= 8; } /** * Getter for property smask. * * @return Value of property smask. * */ public boolean isSmask() { return this.smask; } /** * Setter for property smask. * * @param smask * New value of property smask. */ public void setSmask(final boolean smask) { this.smask = smask; } /** this is the transparency information of the raw image */ protected int transparency[]; /** * Returns the transparency. * * @return the transparency values */ public int[] getTransparency() { return transparency; } /** * Sets the transparency values * * @param transparency * the transparency values */ public void setTransparency(final int transparency[]) { this.transparency = transparency; } /** * Returns the compression level used for images written as a compressed stream. * @return the compression level (0 = best speed, 9 = best compression, -1 is default) * @since 2.1.3 */ public int getCompressionLevel() { return compressionLevel; } /** * Sets the compression level to be used if the image is written as a compressed stream. * @param compressionLevel a value between 0 (best speed) and 9 (best compression) * @since 2.1.3 */ public void setCompressionLevel(final int compressionLevel) { if (compressionLevel < PdfStream.NO_COMPRESSION || compressionLevel > PdfStream.BEST_COMPRESSION) this.compressionLevel = PdfStream.DEFAULT_COMPRESSION; else this.compressionLevel = compressionLevel; } public PdfObject getAccessibleAttribute(final PdfName key) { if (accessibleAttributes != null) return accessibleAttributes.get(key); else return null; } public void setAccessibleAttribute(final PdfName key, final PdfObject value) { if (accessibleAttributes == null) accessibleAttributes = new HashMap<PdfName, PdfObject>(); accessibleAttributes.put(key, value); } public HashMap<PdfName, PdfObject> getAccessibleAttributes() { return accessibleAttributes; } public PdfName getRole() { return role; } public void setRole(final PdfName role) { this.role = role; } public AccessibleElementId getId() { if (id == null) id = new AccessibleElementId(); return id; } public void setId(final AccessibleElementId id) { this.id = id; } public boolean isInline() { return true; } // AWT related methods (remove this if you port to Android / GAE) /** * Gets an instance of an Image from a java.awt.Image. * * @param image * the <CODE>java.awt.Image</CODE> to convert * @param color * if different from <CODE>null</CODE> the transparency pixels * are replaced by this color * @param forceBW * if <CODE>true</CODE> the image is treated as black and white * @return an object of type <CODE>ImgRaw</CODE> * @throws BadElementException * on error * @throws IOException * on error */ public static Image getInstance(final java.awt.Image image, final java.awt.Color color, boolean forceBW) throws BadElementException, IOException { if (image instanceof java.awt.image.BufferedImage) { java.awt.image.BufferedImage bi = (java.awt.image.BufferedImage) image; if (bi.getType() == java.awt.image.BufferedImage.TYPE_BYTE_BINARY && bi.getColorModel().getPixelSize() == 1) { forceBW = true; } } java.awt.image.PixelGrabber pg = new java.awt.image.PixelGrabber(image, 0, 0, -1, -1, true); try { pg.grabPixels(); } catch (InterruptedException e) { throw new IOException( MessageLocalization.getComposedMessage("java.awt.image.interrupted.waiting.for.pixels")); } if ((pg.getStatus() & java.awt.image.ImageObserver.ABORT) != 0) { throw new IOException( MessageLocalization.getComposedMessage("java.awt.image.fetch.aborted.or.errored")); } int w = pg.getWidth(); int h = pg.getHeight(); int[] pixels = (int[]) pg.getPixels(); if (forceBW) { int byteWidth = w / 8 + ((w & 7) != 0 ? 1 : 0); byte[] pixelsByte = new byte[byteWidth * h]; int index = 0; int size = h * w; int transColor = 1; if (color != null) { transColor = color.getRed() + color.getGreen() + color.getBlue() < 384 ? 0 : 1; } int transparency[] = null; int cbyte = 0x80; int wMarker = 0; int currByte = 0; if (color != null) { for (int j = 0; j < size; j++) { int alpha = pixels[j] >> 24 & 0xff; if (alpha < 250) { if (transColor == 1) currByte |= cbyte; } else { if ((pixels[j] & 0x888) != 0) currByte |= cbyte; } cbyte >>= 1; if (cbyte == 0 || wMarker + 1 >= w) { pixelsByte[index++] = (byte) currByte; cbyte = 0x80; currByte = 0; } ++wMarker; if (wMarker >= w) wMarker = 0; } } else { for (int j = 0; j < size; j++) { if (transparency == null) { int alpha = pixels[j] >> 24 & 0xff; if (alpha == 0) { transparency = new int[2]; /* bugfix by M.P. Liston, ASC, was: ... ? 1: 0; */ transparency[0] = transparency[1] = (pixels[j] & 0x888) != 0 ? 0xff : 0; } } if ((pixels[j] & 0x888) != 0) currByte |= cbyte; cbyte >>= 1; if (cbyte == 0 || wMarker + 1 >= w) { pixelsByte[index++] = (byte) currByte; cbyte = 0x80; currByte = 0; } ++wMarker; if (wMarker >= w) wMarker = 0; } } return Image.getInstance(w, h, 1, 1, pixelsByte, transparency); } else { byte[] pixelsByte = new byte[w * h * 3]; byte[] smask = null; int index = 0; int size = h * w; int red = 255; int green = 255; int blue = 255; if (color != null) { red = color.getRed(); green = color.getGreen(); blue = color.getBlue(); } int transparency[] = null; if (color != null) { for (int j = 0; j < size; j++) { int alpha = pixels[j] >> 24 & 0xff; if (alpha < 250) { pixelsByte[index++] = (byte) red; pixelsByte[index++] = (byte) green; pixelsByte[index++] = (byte) blue; } else { pixelsByte[index++] = (byte) (pixels[j] >> 16 & 0xff); pixelsByte[index++] = (byte) (pixels[j] >> 8 & 0xff); pixelsByte[index++] = (byte) (pixels[j] & 0xff); } } } else { int transparentPixel = 0; smask = new byte[w * h]; boolean shades = false; for (int j = 0; j < size; j++) { byte alpha = smask[j] = (byte) (pixels[j] >> 24 & 0xff); /* bugfix by Chris Nokleberg */ if (!shades) { if (alpha != 0 && alpha != -1) { shades = true; } else if (transparency == null) { if (alpha == 0) { transparentPixel = pixels[j] & 0xffffff; transparency = new int[6]; transparency[0] = transparency[1] = transparentPixel >> 16 & 0xff; transparency[2] = transparency[3] = transparentPixel >> 8 & 0xff; transparency[4] = transparency[5] = transparentPixel & 0xff; // Added by Michael Klink // Check whether this value for transparent pixels // has already been used for a non-transparent one // before this position for (int prevPixel = 0; prevPixel < j; prevPixel++) { if ((pixels[prevPixel] & 0xffffff) == transparentPixel) { // found a prior use of the transparentPixel color // and, therefore, cannot make use of this color // for transparency; we could still use an image // mask but for simplicity let's use a soft mask // which already is implemented here shades = true; break; } } } } else if (((pixels[j] & 0xffffff) != transparentPixel) && (alpha == 0)) { shades = true; } else if (((pixels[j] & 0xffffff) == transparentPixel) && (alpha != 0)) { shades = true; } } pixelsByte[index++] = (byte) (pixels[j] >> 16 & 0xff); pixelsByte[index++] = (byte) (pixels[j] >> 8 & 0xff); pixelsByte[index++] = (byte) (pixels[j] & 0xff); } if (shades) transparency = null; else smask = null; } Image img = Image.getInstance(w, h, 3, 8, pixelsByte, transparency); if (smask != null) { Image sm = Image.getInstance(w, h, 1, 8, smask); try { sm.makeMask(); img.setImageMask(sm); } catch (DocumentException de) { throw new ExceptionConverter(de); } } return img; } } /** * Gets an instance of an Image from a java.awt.Image. * * @param image * the <CODE>java.awt.Image</CODE> to convert * @param color * if different from <CODE>null</CODE> the transparency pixels * are replaced by this color * @return an object of type <CODE>ImgRaw</CODE> * @throws BadElementException * on error * @throws IOException * on error */ public static Image getInstance(final java.awt.Image image, final java.awt.Color color) throws BadElementException, IOException { return Image.getInstance(image, color, false); } /** * Gets an instance of a Image from a java.awt.Image. * The image is added as a JPEG with a user defined quality. * * @param writer * the <CODE>PdfWriter</CODE> object to which the image will be added * @param awtImage * the <CODE>java.awt.Image</CODE> to convert * @param quality * a float value between 0 and 1 * @return an object of type <CODE>PdfTemplate</CODE> * @throws BadElementException * on error * @throws IOException */ public static Image getInstance(final PdfWriter writer, final java.awt.Image awtImage, final float quality) throws BadElementException, IOException { return getInstance(new PdfContentByte(writer), awtImage, quality); } /** * Gets an instance of a Image from a java.awt.Image. * The image is added as a JPEG with a user defined quality. * * @param cb * the <CODE>PdfContentByte</CODE> object to which the image will be added * @param awtImage * the <CODE>java.awt.Image</CODE> to convert * @param quality * a float value between 0 and 1 * @return an object of type <CODE>PdfTemplate</CODE> * @throws BadElementException * on error * @throws IOException */ public static Image getInstance(final PdfContentByte cb, final java.awt.Image awtImage, final float quality) throws BadElementException, IOException { java.awt.image.PixelGrabber pg = new java.awt.image.PixelGrabber(awtImage, 0, 0, -1, -1, true); try { pg.grabPixels(); } catch (InterruptedException e) { throw new IOException( MessageLocalization.getComposedMessage("java.awt.image.interrupted.waiting.for.pixels")); } if ((pg.getStatus() & java.awt.image.ImageObserver.ABORT) != 0) { throw new IOException( MessageLocalization.getComposedMessage("java.awt.image.fetch.aborted.or.errored")); } int w = pg.getWidth(); int h = pg.getHeight(); PdfTemplate tp = cb.createTemplate(w, h); PdfGraphics2D g2d = new PdfGraphics2D(tp, w, h, null, false, true, quality); g2d.drawImage(awtImage, 0, 0, null); g2d.dispose(); return getInstance(tp); } }