Example usage for com.lowagie.text.pdf PdfName DEVICERGB

List of usage examples for com.lowagie.text.pdf PdfName DEVICERGB

Introduction

In this page you can find the example usage for com.lowagie.text.pdf PdfName DEVICERGB.

Prototype

PdfName DEVICERGB

To view the source code for com.lowagie.text.pdf PdfName DEVICERGB.

Click Source Link

Document

A name

Usage

From source file:de.offis.health.icardea.cied.pdf.extractor.PDFiText2Extractor.java

License:LGPL

/**
 * @param fullExportDirectoryPath/*from  w w w. j av a2  s .c  om*/
 * @param pdfObjectCounter
 * @param pdfObject
 * @throws IOException
 * @throws Exception
 * @throws FileNotFoundException
 */
private void extractImageFromPdfObject(String fullExportDirectoryPath, int pdfObjectCounter,
        PdfObject pdfObject) throws IOException, Exception, FileNotFoundException {
    boolean rawByteArray = false;

    if (pdfObject != null) {
        if (pdfObject.isStream()) {
            PdfStream pdfStream = (PdfStream) pdfObject;
            PdfObject pdfObjectSubType = pdfStream.get(PdfName.SUBTYPE);

            // Check PDF subtype and make sure it's an Image type
            if (pdfObjectSubType != null && pdfObjectSubType.toString().equals(PdfName.IMAGE.toString())) {
                // Now we have a PDF stream object with an image but what is that exactly?
                byte[] byteArrayImage = null;

                /*
                 * DCTDecode isn't supported by iText2.
                 * The image can be treated as JPEG (we have already
                 * verified it's an image):
                 * http://www.mail-archive.com/itext-questions@lists.sourceforge.net/msg48307.html
                 * 
                 * Check what kind of decoding has to be applied...and
                 * get the byte array containing the image.
                 */
                if ((pdfStream.get(PdfName.FILTER)).toString().equals(PdfName.DCTDECODE.toString())) {
                    // Get the RAW byte array
                    byteArrayImage = PdfReader.getStreamBytesRaw((PRStream) pdfStream);
                    rawByteArray = true;
                } else {
                    /*
                     * PdfReader.getStreamBytes(PRStream) should
                     * automatically apply all decoding filters.
                     * @see com.lowagie.text.pdf.PdfReader#getStreamBytes(PRStream)
                     */
                    byteArrayImage = PdfReader.getStreamBytes((PRStream) pdfStream);
                    rawByteArray = false;
                }

                /*
                // Test PdfImage - START
                logger.trace("");
                logger.trace("");
                        
                if (pdfStream instanceof PdfImage) {
                   PdfImage pdfImage = (PdfImage) pdfStream;
                   logger.trace("");
                   logger.trace("Output for pdfImage object...");
                   logger.trace("pdfImage --> pdfName --> Id..............: " + pdfImage.get(PdfName.ID));
                   logger.trace("pdfImage --> pdfName --> Image...........: " + pdfImage.get(PdfName.IMAGE));
                   logger.trace("pdfImage --> pdfName --> ImageB..........: " + pdfImage.get(PdfName.IMAGEB));
                   logger.trace("pdfImage --> pdfName --> ImageC..........: " + pdfImage.get(PdfName.IMAGEC));
                   logger.trace("pdfImage --> pdfName --> ImageI..........: " + pdfImage.get(PdfName.IMAGEI));
                   logger.trace("pdfImage --> pdfName --> Imagemask.......: " + pdfImage.get(PdfName.IMAGEMASK));
                   logger.trace("pdfImage --> pdfName --> Info............: " + pdfImage.get(PdfName.INFO));
                   logger.trace("pdfImage --> pdfName --> Name............: " + pdfImage.get(PdfName.NAME));
                   logger.trace("pdfImage --> pdfName --> Named...........: " + pdfImage.get(PdfName.NAMED));
                } else {
                   logger.trace("pdfStream is NO instanceof PdfImage");
                }
                        
                // STREAM
                logger.trace("");
                logger.trace("Output for pdfImage object...");
                logger.trace("pdfObject.toString()).....................: " + pdfObject.toString());
                logger.trace("pdfObjectCounter..........................: " + pdfObjectCounter);
                logger.trace("pdfStream --> pdfName --> Page............: " + pdfStream. get(PdfName.PAGE));
                logger.trace("pdfObject.getIndRef().getNumber().........: " + (pdfObject.getIndRef()!=null?pdfObject.getIndRef().toString():"null"));
                logger.trace("pdfStream.getIndRef().getNumber().........: " + (pdfStream.getIndRef()!=null?pdfStream.getIndRef().toString():"null"));
                logger.trace("pdfStream --> pdfName --> toString........: " + pdfStream.toString());
                logger.trace("pdfStream --> pdfName --> Width...........: " + pdfStream.get(PdfName.WIDTH));
                logger.trace("pdfStream --> pdfName --> Height..........: " + pdfStream.get(PdfName.HEIGHT));
                logger.trace("pdfStream --> pdfName --> BitsPerComponent: " + pdfStream.get(PdfName.BITSPERCOMPONENT));
                logger.trace("pdfStream --> pdfName --> BitsPerSample...: " + pdfStream.get(PdfName.BITSPERSAMPLE));
                logger.trace("pdfStream --> pdfName --> ColorSpace......: " + pdfStream.get(PdfName.COLORSPACE));
                logger.trace("pdfStream --> pdfName --> Filter..........: " + pdfStream.get(PdfName.FILTER));
                logger.trace("pdfStream --> pdfName --> Filter - as name: " + pdfStream.getAsName(PdfName.FILTER));
                logger.trace("pdfStream --> pdfName --> Name............: " + pdfStream.get(PdfName.NAME));
                logger.trace("pdfStream --> pdfName --> SubType.........: " + pdfStream.get(PdfName.SUBTYPE));
                */

                // Extract the image name
                String streamImageName = (pdfStream.get(PdfName.NAME) == null ? null
                        : pdfStream.get(PdfName.NAME).toString());
                if (streamImageName != null && streamImageName.length() > 1
                        && streamImageName.startsWith("/")) {
                    streamImageName = streamImageName.substring(1);
                } else {
                    streamImageName = null;
                } // end if..else

                String exportFileWithoutExtension = (fullExportDirectoryPath != null ? fullExportDirectoryPath
                        : this.fullPDFDirectoryPath)
                        + GlobalTools.getFileNameWithoutExtension(this.fullPDFFilePath) + "_(" + "p000" + "_ref"
                        + REF_NUMBER_FORMAT.format(pdfObjectCounter)
                        + (streamImageName == null ? "_unk" : "_" + streamImageName) + ")";

                // Test
                FileOutputStream fileOutputStream = null;

                if (rawByteArray) {
                    fileOutputStream = new FileOutputStream(exportFileWithoutExtension + ".jpg");
                    fileOutputStream.write(byteArrayImage);
                    fileOutputStream.flush();
                    fileOutputStream.close();
                    fileOutputStream = null;
                } else {
                    /* 
                     * Check image details
                     */
                    int pdfImageWidth = -1;
                    int pdfImageHeight = -1;
                    int pdfImageBitsPerComponent = -1;

                    try {
                        if (pdfStream.get(PdfName.BITSPERCOMPONENT).isNumber()) {
                            pdfImageBitsPerComponent = new Integer(
                                    pdfStream.get(PdfName.BITSPERCOMPONENT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting BITSPERCOMPONENT (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    try {
                        if (pdfStream.get(PdfName.HEIGHT).isNumber()) {
                            pdfImageHeight = new Integer(pdfStream.get(PdfName.HEIGHT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting HEIGHT (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    try {
                        if (pdfStream.get(PdfName.WIDTH).isNumber()) {
                            pdfImageWidth = new Integer(pdfStream.get(PdfName.WIDTH).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting WIDTH (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    if (PdfName.DEVICERGB.equals(pdfStream.get(PdfName.COLORSPACE))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0 && pdfImageHeight > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(byteArrayImage,
                                pdfImageWidth, pdfImageHeight, pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else if (PdfName.DEVICEGRAY.equals(pdfStream.get(PdfName.COLORSPACE))
                            && PdfName.RUNLENGTHDECODE.equals(pdfStream.get(PdfName.FILTER))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(
                                ImageProcessingTools.runLengthDecode(byteArrayImage), pdfImageWidth, 2233,
                                pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else {
                        logger.error("Unsupported Image format or missing information to convert the image.");
                    } // end if..else
                }
            } // end if
        } // end if 
    } // end if
}

From source file:de.offis.health.icardea.cied.pdf.extractor.PDFiText2Extractor.java

License:LGPL

/**
 * @param fullExportDirectoryPath//from  ww  w.  ja  v  a  2  s  .  c  o m
 * @param pdfObjectCounter
 * @param pdfObject
 * @throws IOException
 * @throws Exception
 * @throws FileNotFoundException
 */
private void extractImageFromPdfObjectExperimental(String fullExportDirectoryPath, int pdfObjectCounter,
        PdfObject pdfObject) throws IOException, Exception, FileNotFoundException {
    boolean rawByteArray = false;

    if (pdfObject != null) {
        if (pdfObject.isStream()) {
            //|| pdfObject.isDictionary()) {
            //PdfObject pdfObjectSubType = null;
            ////PdfName pdfObjectSubType = null;
            ////PdfStream pdfStream = null;

            //if (pdfObject.isStream()) {
            PdfStream pdfStream = (PdfStream) pdfObject;
            //pdfObjectSubType = pdfStream.get(PdfName.SUBTYPE);
            PdfName pdfObjectSubType = (PdfName) PdfReader.getPdfObject(pdfStream.get(PdfName.SUBTYPE)); // J.U. - 2011-08-22

            /*               
                        } else if (pdfObject.isDictionary()) {
                           PdfDictionary pdfDictionary = (PdfDictionary)PdfReader.getPdfObject(pdfObject);
                           //PdfName pdfObjectSubType = (PdfName)PdfReader.getPdfObject(pdfDictionary.get(PdfName.SUBTYPE));
                           pdfObjectSubType = (PdfName)PdfReader.getPdfObject(pdfDictionary.get(PdfName.SUBTYPE));
                           if (pdfObjectSubType != null && pdfObjectSubType.toString().equals(PdfName.IMAGE.toString())) {
                              int xRefIndex = pdfObject.getIndRef().getNumber();
                              PdfObject innerPdfObject = 
                           }
                        }
            */

            // Check PDF subtype and make sure it's an Image type
            if (pdfObjectSubType != null && pdfObjectSubType.toString().equals(PdfName.IMAGE.toString())) {
                // Now we have a PDF stream object with an image but what is that exactly?
                byte[] byteArrayImage = null;

                /*
                 * DCTDecode isn't supported by iText2.
                 * The image can be treated as JPEG (we have already
                 * verified it's an image):
                 * http://www.mail-archive.com/itext-questions@lists.sourceforge.net/msg48307.html
                 * 
                 * Check what kind of decoding has to be applied...and
                 * get the byte array containing the image.
                 */
                if ((pdfStream.get(PdfName.FILTER)).toString().equals(PdfName.DCTDECODE.toString())) {
                    // Get the RAW byte array
                    byteArrayImage = PdfReader.getStreamBytesRaw((PRStream) pdfStream);
                    rawByteArray = true;
                } else {
                    /*
                     * PdfReader.getStreamBytes(PRStream) should
                     * automatically apply all decoding filters.
                     * @see com.lowagie.text.pdf.PdfReader#getStreamBytes(PRStream)
                     */
                    byteArrayImage = PdfReader.getStreamBytes((PRStream) pdfStream);
                    rawByteArray = false;
                }

                /*
                // Test PdfImage - START
                logger.trace("");
                logger.trace("");
                        
                if (pdfStream instanceof PdfImage) {
                   PdfImage pdfImage = (PdfImage) pdfStream;
                   logger.trace("");
                   logger.trace("Output for pdfImage object...");
                   logger.trace("pdfImage --> pdfName --> Id..............: " + pdfImage.get(PdfName.ID));
                   logger.trace("pdfImage --> pdfName --> Image...........: " + pdfImage.get(PdfName.IMAGE));
                   logger.trace("pdfImage --> pdfName --> ImageB..........: " + pdfImage.get(PdfName.IMAGEB));
                   logger.trace("pdfImage --> pdfName --> ImageC..........: " + pdfImage.get(PdfName.IMAGEC));
                   logger.trace("pdfImage --> pdfName --> ImageI..........: " + pdfImage.get(PdfName.IMAGEI));
                   logger.trace("pdfImage --> pdfName --> Imagemask.......: " + pdfImage.get(PdfName.IMAGEMASK));
                   logger.trace("pdfImage --> pdfName --> Info............: " + pdfImage.get(PdfName.INFO));
                   logger.trace("pdfImage --> pdfName --> Name............: " + pdfImage.get(PdfName.NAME));
                   logger.trace("pdfImage --> pdfName --> Named...........: " + pdfImage.get(PdfName.NAMED));
                } else {
                   logger.trace("pdfStream is NO instanceof PdfImage");
                }
                        
                // STREAM
                logger.trace("");
                logger.trace("Output for pdfImage object...");
                logger.trace("pdfObject.toString()).....................: " + pdfObject.toString());
                logger.trace("pdfObjectCounter..........................: " + pdfObjectCounter);
                logger.trace("pdfStream --> pdfName --> Page............: " + pdfStream. get(PdfName.PAGE));
                logger.trace("pdfObject.getIndRef().getNumber().........: " + (pdfObject.getIndRef()!=null?pdfObject.getIndRef().toString():"null"));
                logger.trace("pdfStream.getIndRef().getNumber().........: " + (pdfStream.getIndRef()!=null?pdfStream.getIndRef().toString():"null"));
                logger.trace("pdfStream --> pdfName --> toString........: " + pdfStream.toString());
                logger.trace("pdfStream --> pdfName --> Width...........: " + pdfStream.get(PdfName.WIDTH));
                logger.trace("pdfStream --> pdfName --> Height..........: " + pdfStream.get(PdfName.HEIGHT));
                logger.trace("pdfStream --> pdfName --> BitsPerComponent: " + pdfStream.get(PdfName.BITSPERCOMPONENT));
                logger.trace("pdfStream --> pdfName --> BitsPerSample...: " + pdfStream.get(PdfName.BITSPERSAMPLE));
                logger.trace("pdfStream --> pdfName --> ColorSpace......: " + pdfStream.get(PdfName.COLORSPACE));
                logger.trace("pdfStream --> pdfName --> Filter..........: " + pdfStream.get(PdfName.FILTER));
                logger.trace("pdfStream --> pdfName --> Filter - as name: " + pdfStream.getAsName(PdfName.FILTER));
                logger.trace("pdfStream --> pdfName --> Name............: " + pdfStream.get(PdfName.NAME));
                logger.trace("pdfStream --> pdfName --> SubType.........: " + pdfStream.get(PdfName.SUBTYPE));
                */

                // Extract the image name
                String streamImageName = (pdfStream.get(PdfName.NAME) == null ? null
                        : pdfStream.get(PdfName.NAME).toString());
                if (streamImageName != null && streamImageName.length() > 1
                        && streamImageName.startsWith("/")) {
                    streamImageName = streamImageName.substring(1);
                } else {
                    streamImageName = null;
                } // end if..else

                String exportFileWithoutExtension = (fullExportDirectoryPath != null ? fullExportDirectoryPath
                        : this.fullPDFDirectoryPath)
                        + GlobalTools.getFileNameWithoutExtension(this.fullPDFFilePath) + "_(" + "p000" + "_ref"
                        + REF_NUMBER_FORMAT.format(pdfObjectCounter)
                        + (streamImageName == null ? "_unk" : "_" + streamImageName) + ")";

                // Test
                FileOutputStream fileOutputStream = null;

                if (rawByteArray) {
                    fileOutputStream = new FileOutputStream(exportFileWithoutExtension + ".jpg");
                    fileOutputStream.write(byteArrayImage);
                    fileOutputStream.flush();
                    fileOutputStream.close();
                    fileOutputStream = null;
                } else {
                    /* 
                     * Check image details
                     */
                    int pdfImageWidth = -1;
                    int pdfImageHeight = -1;
                    int pdfImageBitsPerComponent = -1;

                    try {
                        if (pdfStream.get(PdfName.BITSPERCOMPONENT).isNumber()) {
                            pdfImageBitsPerComponent = new Integer(
                                    pdfStream.get(PdfName.BITSPERCOMPONENT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting BITSPERCOMPONENT (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    try {
                        if (pdfStream.get(PdfName.HEIGHT).isNumber()) {
                            pdfImageHeight = new Integer(pdfStream.get(PdfName.HEIGHT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting HEIGHT (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    try {
                        if (pdfStream.get(PdfName.WIDTH).isNumber()) {
                            pdfImageWidth = new Integer(pdfStream.get(PdfName.WIDTH).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting WIDTH (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    if (PdfName.DEVICERGB.equals(pdfStream.get(PdfName.COLORSPACE))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0 && pdfImageHeight > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(byteArrayImage,
                                pdfImageWidth, pdfImageHeight, pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else if (PdfName.DEVICEGRAY.equals(pdfStream.get(PdfName.COLORSPACE))
                            && PdfName.RUNLENGTHDECODE.equals(pdfStream.get(PdfName.FILTER))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(
                                ImageProcessingTools.runLengthDecode(byteArrayImage), pdfImageWidth, 2233,
                                pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else {
                        logger.error("Unsupported Image format or missing information to convert the image.");
                    } // end if..else
                }
            } // end if
        } // end if 
    } // end if
}

From source file:de.offis.health.icardea.cied.pdf.extractor.PDFiText4Extractor.java

License:LGPL

/**
 * <p>//from  w ww.  j a v a 2 s  . c o  m
 * This method searches for all image objects from the currently processed
 * PDF file and stores them as PDF in the given export directory or in the
 * same directory where the original PDF file is stored.
 * </p>
 * <p>
 * The filename of the images is build based on the original PDF filename
 * (without extension) and additional details like page number, image
 * number and if available the internal image name.
 * </p>
 * @param fullExportDirectoryPath The optional full export path where the images
 * should be stored. If not given, the location of the original PDF file is used.
 * @throws Exception
 */
private void imageExtractor(String fullExportDirectoryPath) throws Exception {
    if (fullExportDirectoryPath != null) {
        fullExportDirectoryPath = GlobalTools.checkDirectoryPath(fullExportDirectoryPath);
        File exportDirectory = new File(fullExportDirectoryPath);
        if (!exportDirectory.exists()) {
            exportDirectory.mkdirs();
        } // end if
    } // end if

    int totalNumberOfPDFObjects = pdfReader.getXrefSize();
    for (int pdfObjectCounter = 0; pdfObjectCounter < totalNumberOfPDFObjects; pdfObjectCounter++) {
        PdfObject pdfObject = pdfReader.getPdfObject(pdfObjectCounter);
        if (pdfObject != null) {
            if (pdfObject.isStream()) {
                PdfStream pdfStream = (PdfStream) pdfObject;
                PdfObject pdfObjectSubType = pdfStream.get(PdfName.SUBTYPE);

                if (pdfObject == null) {
                    logger.debug("The internal PDF object is null.");
                } // end if

                if (!pdfObject.isStream()) {
                    logger.debug("The internal PDF object is not representing a stream object.");
                } // end if

                // Check PDF subtype and make sure it's an Image type
                if (pdfObjectSubType != null && pdfObjectSubType.toString().equals(PdfName.IMAGE.toString())) {
                    // Now we have a PDF stream object with an image but what is that exactly?
                    //byte[] byteArrayImage = PdfReader.getStreamBytesRaw((PRStream) pdfStream);
                    byte[] byteArrayImage = null;
                    if (PdfName.FLATEDECODE.equals(pdfStream.getAsName(PdfName.FILTER))) {
                        byteArrayImage = PdfReader.getStreamBytes((PRStream) pdfStream);
                        // else if other filter (not supported yet)
                    } else {
                        byteArrayImage = PdfReader.getStreamBytesRaw((PRStream) pdfStream);
                    } // end if..else

                    // Test PdfImage - START
                    /*
                    PdfImage pdfImage = (PdfImage) ((PdfStream)((PRStream)pdfStream));
                    logger.trace("pdfImage --> pdfName --> Width...........: " + pdfStream.get(PdfName.WIDTH));
                    logger.trace("pdfImage --> pdfName --> Height..........: " + pdfStream.get(PdfName.HEIGHT));
                    logger.trace("pdfImage --> pdfName --> Id..............: " + pdfImage.get(PdfName.ID));
                    logger.trace("pdfImage --> pdfName --> Image...........: " + pdfImage.get(PdfName.IMAGE));
                    logger.trace("pdfImage --> pdfName --> ImageB..........: " + pdfImage.get(PdfName.IMAGEB));
                    logger.trace("pdfImage --> pdfName --> ImageC..........: " + pdfImage.get(PdfName.IMAGEC));
                    logger.trace("pdfImage --> pdfName --> ImageI..........: " + pdfImage.get(PdfName.IMAGEI));
                    logger.trace("pdfImage --> pdfName --> Imagemask.......: " + pdfImage.get(PdfName.IMAGEMASK));
                    logger.trace("pdfImage --> pdfName --> Info............: " + pdfImage.get(PdfName.INFO));
                    logger.trace("pdfImage --> pdfName --> Name............: " + pdfImage.get(PdfName.NAME));
                    logger.trace("pdfImage --> pdfName --> Named...........: " + pdfImage.get(PdfName.NAMED));
                    logger.trace("pdfImage --> pdfName --> Page............: " + pdfStream.get(PdfName.PAGE));
                    */
                    // Test PdfImage - STOP

                    // STREAM
                    /*
                    logger.trace("pdfObject.toString()): " + pdfObject.toString());
                    logger.trace("pdfObjectCounter.................: " + pdfObjectCounter);
                    logger.trace("pdfObject.getIndRef().getNumber(): " + (pdfObject.getIndRef()!=null?pdfObject.getIndRef().toString():"null"));
                    logger.trace("pdfStream.getIndRef().getNumber(): " + (pdfStream.getIndRef()!=null?pdfStream.getIndRef().toString():"null"));
                    logger.trace("pdfStream --> pdfName --> toString........: " + pdfStream.toString());
                    logger.trace("pdfStream --> pdfName --> Width...........: " + pdfStream.get(PdfName.WIDTH));
                    logger.trace("pdfStream --> pdfName --> Height..........: " + pdfStream.get(PdfName.HEIGHT));
                    logger.trace("pdfStream --> pdfName --> BitsPerComponent: " + pdfStream.get(PdfName.BITSPERCOMPONENT));
                    logger.trace("pdfStream --> pdfName --> BitsPerSample...: " + pdfStream.get(PdfName.BITSPERSAMPLE));
                    logger.trace("pdfStream --> pdfName --> ColorSpace......: " + pdfStream.get(PdfName.COLORSPACE));
                    logger.trace("pdfStream --> pdfName --> CCITTFaxDecode..: " + pdfStream.get(PdfName.CCITTFAXDECODE));
                    logger.trace("pdfStream --> pdfName --> Document........: " + pdfStream.get(PdfName.DOCUMENT));
                    logger.trace("pdfStream --> pdfName --> Decode..........: " + pdfStream.get(PdfName.DECODE));
                    logger.trace("pdfStream --> pdfName --> DecodeParms.....: " + pdfStream.get(PdfName.DECODEPARMS));
                    logger.trace("pdfStream --> pdfName --> DeviceGray......: " + pdfStream.get(PdfName.DEVICEGRAY));
                    logger.trace("pdfStream --> pdfName --> DeviceCMYK......: " + pdfStream.get(PdfName.DEVICECMYK));
                    logger.trace("pdfStream --> pdfName --> DeviceRGB.......: " + pdfStream.get(PdfName.DEVICERGB));
                    logger.trace("pdfStream --> pdfName --> Filter..........: " + pdfStream.get(PdfName.FILTER));
                    logger.trace("pdfStream --> pdfName --> Filter - as name: " + pdfStream.getAsName(PdfName.FILTER));
                            
                    logger.trace("pdfStream --> pdfName --> Id..............: " + pdfStream.get(PdfName.ID));
                    logger.trace("pdfStream --> pdfName --> Image...........: " + pdfStream.get(PdfName.IMAGE));
                    logger.trace("pdfStream --> pdfName --> ImageB..........: " + pdfStream.get(PdfName.IMAGEB));
                    logger.trace("pdfStream --> pdfName --> ImageC..........: " + pdfStream.get(PdfName.IMAGEC));
                    logger.trace("pdfStream --> pdfName --> ImageI..........: " + pdfStream.get(PdfName.IMAGEI));
                    logger.trace("pdfStream --> pdfName --> Imagemask.......: " + pdfStream.get(PdfName.IMAGEMASK));
                    logger.trace("pdfStream --> pdfName --> Info............: " + pdfStream.get(PdfName.INFO));
                    logger.trace("pdfStream --> pdfName --> Name............: " + pdfStream.get(PdfName.NAME));
                    logger.trace("pdfStream --> pdfName --> Named...........: " + pdfStream.get(PdfName.NAMED));
                    logger.trace("pdfStream --> pdfName --> Named - as name.: " + pdfStream.getAsName(PdfName.NAMED));
                            
                    logger.trace("pdfStream --> pdfName --> Page............: " + pdfStream.get(PdfName.PAGE));
                    logger.trace("pdfStream --> pdfName --> PageElement.....: " + pdfStream.get(PdfName.PAGEELEMENT));
                    logger.trace("pdfStream --> pdfName --> Pdf.............: " + pdfStream.get(PdfName.PDF));
                    logger.trace("pdfStream --> pdfName --> PdfDocEncoding..: " + pdfStream.get(PdfName.PDFDOCENCODING));
                    logger.trace("pdfStream --> pdfName --> Position........: " + pdfStream.get(PdfName.POSITION));
                    logger.trace("pdfStream --> pdfName --> Producer........: " + pdfStream.get(PdfName.PRODUCER));
                    logger.trace("pdfStream --> pdfName --> Properties......: " + pdfStream.get(PdfName.PROPERTIES));
                    logger.trace("pdfStream --> pdfName --> Sect............: " + pdfStream.get(PdfName.SECT));
                    logger.trace("pdfStream --> pdfName --> SubType.........: " + pdfStream.get(PdfName.SUBTYPE));
                    logger.trace("pdfStream --> pdfName --> Supplement......: " + pdfStream.get(PdfName.SUPPLEMENT));
                    logger.trace("pdfStream --> pdfName --> Title...........: " + pdfStream.get(PdfName.TITLE));
                    */
                    // logger.trace("pdfImage --> pdfName --> : " + (pdfName.).toString());

                    // Extract the image name
                    String streamImageName = (pdfStream.get(PdfName.NAME) == null ? null
                            : pdfStream.get(PdfName.NAME).toString());
                    if (streamImageName != null && streamImageName.length() > 1
                            && streamImageName.startsWith("/")) {
                        streamImageName = streamImageName.substring(1);
                    } else {
                        streamImageName = null;
                    } // end if..else

                    String exportFileWithoutExtension = (fullExportDirectoryPath != null
                            ? fullExportDirectoryPath
                            : this.fullPDFDirectoryPath)
                            + GlobalTools.getFileNameWithoutExtension(this.fullPDFFilePath) + "_(" + "p000"
                            + "_ref" + REF_NUMBER_FORMAT.format(pdfObjectCounter)
                            + (streamImageName == null ? "_unk" : "_" + streamImageName) + ")";

                    // Test
                    FileOutputStream fileOutputStream = new FileOutputStream(
                            exportFileWithoutExtension + ".jpg");

                    /*
                     * Write given byte array to a file.
                     */
                    fileOutputStream.write(byteArrayImage);
                    fileOutputStream.flush();
                    fileOutputStream.close();
                    fileOutputStream = null;

                    /* 
                     * Check image details
                     */
                    int pdfImageBitsPerComponent = -1;
                    try {
                        if (pdfStream.get(PdfName.BITSPERCOMPONENT).isNumber()) {
                            pdfImageBitsPerComponent = new Integer(
                                    pdfStream.get(PdfName.BITSPERCOMPONENT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                    }

                    int pdfImageHeight = -1;
                    try {
                        if (pdfStream.get(PdfName.HEIGHT).isNumber()) {
                            pdfImageHeight = new Integer(pdfStream.get(PdfName.HEIGHT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                    }

                    int pdfImageWidth = -1;
                    try {
                        if (pdfStream.get(PdfName.WIDTH).isNumber()) {
                            pdfImageWidth = new Integer(pdfStream.get(PdfName.WIDTH).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                    }

                    logger.debug("Height..........:" + pdfImageHeight);
                    logger.debug("Width...........:" + pdfImageWidth);
                    logger.debug("BitsPerComponent:" + pdfImageBitsPerComponent);

                    // or you could try making a java.awt.Image from the array:

                    if (PdfName.DEVICERGB.equals(pdfStream.get(PdfName.COLORSPACE))
                            && PdfName.FLATEDECODE.equals(pdfStream.get(PdfName.FILTER))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0 && pdfImageHeight > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(byteArrayImage,
                                pdfImageWidth, pdfImageHeight, pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else if (PdfName.DEVICEGRAY.equals(pdfStream.get(PdfName.COLORSPACE))
                            && PdfName.RUNLENGTHDECODE.equals(pdfStream.get(PdfName.FILTER))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(
                                ImageProcessingTools.runLengthDecode(byteArrayImage), pdfImageWidth, 2233,
                                pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } // end if...

                    /*
                    Image image = Toolkit.getDefaultToolkit().createImage(imageByteArray);
                            
                            
                    BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(image, pdfImageWidth, pdfImageHeight);
                    if (bufferedImage != null) {
                       System.out.println("Image-Height....:" + bufferedImage.getHeight());
                       System.out.println("Image-Width.....:" + bufferedImage.getWidth());
                       System.out.println("Image-isAlphaP..:" + bufferedImage.isAlphaPremultiplied());
                       File pngOutputFile = new File(exportFileWithoutExtension + "_imageIO.jpg");
                       ImageIO.write(bufferedImage, "jpg", pngOutputFile);
                    }
                    */
                    /**/

                } // end if
            } // end if 
        } // end if
    } // end for
}

From source file:org.alchemy.core.AlcSession.java

License:Open Source License

/** Save the canvas to a single paged PDF file
 * //from w w  w . j  av  a2s  .c  om
 * @param file  The file object to save the pdf to
 * @return      True if save worked, otherwise false
 */
boolean saveSinglePdf(File file) {
    // Get the current 'real' size of the canvas without margins/borders
    java.awt.Rectangle bounds = Alchemy.canvas.getVisibleRect();
    //int singlePdfWidth = Alchemy.window.getWindowSize().width;
    //int singlePdfHeight = Alchemy.window.getWindowSize().height;
    com.lowagie.text.Document document = new com.lowagie.text.Document(
            new com.lowagie.text.Rectangle(bounds.width, bounds.height), 0, 0, 0, 0);
    System.out.println("Save Single Pdf Called: " + file.toString());
    boolean noError = true;

    try {

        PdfWriter singleWriter = PdfWriter.getInstance(document, new FileOutputStream(file));
        document.addTitle("Alchemy Session");
        document.addAuthor(USER_NAME);
        document.addCreator("Alchemy <http://al.chemy.org>");

        // Add metadata and open the document
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        XmpWriter xmp = new XmpWriter(os);
        PdfSchema pdf = new PdfSchema();
        pdf.setProperty(PdfSchema.KEYWORDS, "Alchemy <http://al.chemy.org>");
        //pdf.setProperty(PdfSchema.VERSION, "1.4");
        xmp.addRdfDescription(pdf);
        xmp.close();
        singleWriter.setXmpMetadata(os.toByteArray());

        // To avoid transparent colurs being converted from RGB>CMYK>RGB
        // We have to add everything to a transparency group
        PdfTransparencyGroup transGroup = new PdfTransparencyGroup();
        transGroup.put(PdfName.CS, PdfName.DEVICERGB);

        document.open();

        PdfContentByte cb = singleWriter.getDirectContent();
        PdfTemplate tp = cb.createTemplate(bounds.width, bounds.height);

        document.newPage();

        cb.getPdfWriter().setGroup(transGroup);
        // Make sure the color space is Device RGB
        cb.setDefaultColorspace(PdfName.CS, PdfName.DEVICERGB);

        // Draw into the template and add it to the PDF 
        Graphics2D g2pdf = tp.createGraphics(bounds.width, bounds.height);
        Alchemy.canvas.setGuide(false);
        Alchemy.canvas.vectorCanvas.paintComponent(g2pdf);
        Alchemy.canvas.setGuide(true);
        g2pdf.dispose();
        cb.addTemplate(tp, 0, 0);

    } catch (DocumentException ex) {
        System.err.println(ex);
        noError = false;
    } catch (IOException ex) {
        System.err.println(ex);
        noError = false;
    }

    document.close();

    return noError;
}

From source file:org.alchemy.core.AlcSession.java

License:Open Source License

/** Adds a pdfReadPage to an existing pdf file
 * //from  w  w  w  .  j  av a2s  . c  om
 * @param mainPdf   The main pdf with multiple pages.
 *                  Also used as the destination file.
 * @param tempPdf   The 'new' pdf with one pdfReadPage to be added to the main pdf
 * @return
 */
boolean addPageToPdf(File mainPdf, File tempPdf) {
    try {
        // Destination file created in the temp dir then we will move it
        File dest = new File(DIR_TEMP, "Alchemy.pdf");
        OutputStream output = new FileOutputStream(dest);

        PdfReader reader = new PdfReader(mainPdf.getPath());
        PdfReader newPdf = new PdfReader(tempPdf.getPath());

        // See if the size of the canvas has increased
        // Size of the most recent temp PDF
        com.lowagie.text.Rectangle currentSize = newPdf.getPageSizeWithRotation(1);
        // Size of the session pdf at present
        com.lowagie.text.Rectangle oldSize = reader.getPageSizeWithRotation(1);
        // Sizes to be used from now on
        float pdfWidth = oldSize.getWidth();
        float pdfHeight = oldSize.getHeight();
        if (currentSize.getWidth() > pdfWidth) {
            pdfWidth = currentSize.getWidth();
        }
        if (currentSize.getHeight() > pdfHeight) {
            pdfHeight = currentSize.getHeight();
        }

        // Use the new bigger canvas size if required
        com.lowagie.text.Document document = new com.lowagie.text.Document(
                new com.lowagie.text.Rectangle(pdfWidth, pdfHeight), 0, 0, 0, 0);
        PdfCopy copy = new PdfCopy(document, output);

        // Copy the meta data
        document.addTitle("Alchemy Session");
        document.addAuthor(USER_NAME);
        document.addCreator("Alchemy <http://al.chemy.org>");
        copy.setXmpMetadata(reader.getMetadata());
        document.open();

        // Holds the PDF
        PdfContentByte cb = copy.getDirectContent();

        // Add each page from the main PDF
        for (int i = 0; i < reader.getNumberOfPages();) {
            ++i;
            document.newPage();
            cb.setDefaultColorspace(PdfName.CS, PdfName.DEVICERGB);
            PdfImportedPage page = copy.getImportedPage(reader, i);
            copy.addPage(page);
        }
        // Add the last (new) page
        document.newPage();
        PdfImportedPage lastPage = copy.getImportedPage(newPdf, 1);
        copy.addPage(lastPage);
        output.flush();
        document.close();
        output.close();

        if (dest.exists()) {
            // Save the location of the main pdf
            String mainPdfPath = mainPdf.getPath();
            // Delete the old file
            if (mainPdf.exists()) {
                mainPdf.delete();
            }
            // The final joined up pdf file
            File joinPdf = new File(mainPdfPath);
            // Rename the file
            boolean success = dest.renameTo(joinPdf);
            if (!success) {
                System.err.println("Error moving Pdf");
                return false;
            }

        } else {
            System.err.println("File does not exist?!: " + dest.getAbsolutePath());
            return false;
        }
        return true;

    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}