Example usage for com.itextpdf.text.pdf.parser PdfImageObject getBufferedImage

List of usage examples for com.itextpdf.text.pdf.parser PdfImageObject getBufferedImage

  1. HOME
  2. Java
  3. com.itextpdf
  4. com.itextpdf.text.pdf.parser.*
  5. PdfImageObject
  6. getBufferedImage

Introduction

In this page you can find the example usage for com.itextpdf.text.pdf.parser PdfImageObject getBufferedImage.

Prototype

public java.awt.image.BufferedImage getBufferedImage() throws IOException

Source Link

Usage

From source file:org.gmdev.pdftrick.engine.ImageListenerShowThumb.java

License:Open Source License

/**
 * extracts the images contained in selected page and convert it in a BufferedImage to add and show to the center panel.
 * @param renderInfo/*w ww.  ja  va2  s.  com*/
 */
private void render(ImageRenderInfo renderInfo) {
    final HashMap<Integer, String> rotationFromPages = factory.getRotationFromPages();
    boolean isInline = false;

    PdfImageObject image = null;
    try {
        BufferedImage buffImg = null;
        if (renderInfo.getRef() == null) {
            isInline = true;
            inlineImageCounter += 1;
        }
        try {
            image = renderInfo.getImage();
        } catch (UnsupportedPdfException updfe) {
            try {
                if (isInline) {
                    buffImg = null;
                } else {
                    buffImg = CustomExtraImgReader.readIndexedPNG(renderInfo.getRef().getNumber(),
                            factory.getResultFile());
                }
            } catch (Exception e) {
                logger.error("Exception", e);
                PdfTrickMessages.append("ERROR", Consts.SENDLOG_MSG);
                unsupportedImage++;
                return;
            }
        }

        if (image != null) {
            BufferedImage buffPic = null;
            try {
                // if image is JBIG2 type i need a custom way and using jbig2 ImageIO plugin
                if (image.getFileType().equalsIgnoreCase("JBIG2")) {
                    buffPic = CustomExtraImgReader.readJBIG2(image);
                } else {
                    buffPic = image.getBufferedImage();
                }
            } catch (IIOException iioex) {
                byte[] imageByteArray = image.getImageAsBytes();
                try {
                    buffPic = CustomExtraImgReader.readCMYK_JPG(imageByteArray);
                } catch (Exception e) {
                    logger.error("Exception", e);
                    PdfTrickMessages.append("ERROR", Consts.SENDLOG_MSG);
                    unsupportedImage++;
                    return;
                }
            } catch (Exception e) {
                logger.error("Exception", e);
                PdfTrickMessages.append("ERROR", Consts.SENDLOG_MSG);
                unsupportedImage++;
                return;
            }

            // check if image contains a mask image
            BufferedImage buffMask = null;
            PdfDictionary imageDictionary = image.getDictionary();
            PRStream maskStream = (PRStream) imageDictionary.getAsStream(PdfName.SMASK);

            if (maskStream != null) {
                // if i have an smak object i check that is not a jpeg format, because this may cause some problem on offscreen rendering
                // usually all imges with mask are png ... and there aren't problems, if image is jpg i discard the mask :)
                if (!image.getFileType().equalsIgnoreCase("jpg") && buffPic != null) {
                    PdfImageObject maskImage = new PdfImageObject(maskStream);
                    buffMask = maskImage.getBufferedImage();
                    Image img = PdfTrickUtils.TransformGrayToTransparency(buffMask);
                    buffImg = PdfTrickUtils.ApplyTransparency(buffPic, img);
                } else {
                    buffImg = buffPic;
                }
            } else {
                buffImg = buffPic;
            }
        }

        String flip = "";
        String rotate = "";
        Matrix matrix = renderInfo.getImageCTM();
        String angle = "" + rotationFromPages.get(numPage);

        // experimental 
        float i11 = matrix.get(Matrix.I11); // if negative -> horizontal flip
        float i12 = matrix.get(Matrix.I12); // if negative -> 90 degree rotation
        float i21 = matrix.get(Matrix.I21); // if negative -> 270 degree rotation
        float i22 = matrix.get(Matrix.I22); // if negative -> vertical flip

        // flip and rotation ... from matrix if i11 or i22 is negative i have to flip image
        if (("" + i11).charAt(0) == '-') {
            flip = "fh";
        } else if (("" + i22).charAt(0) == '-') {
            flip = "fv";
        }

        if (angle.equalsIgnoreCase("270") || ("" + i21).charAt(0) == '-') {
            rotate = "270";
        } else if (angle.equalsIgnoreCase("180")) {
            rotate = "180";
        } else if (angle.equalsIgnoreCase("90") || ("" + i12).charAt(0) == '-') {
            rotate = "90";
        }

        if (buffImg != null) {
            buffImg = PdfTrickUtils.adjustImage(buffImg, flip, rotate);
            RenderedImageAttributes imageAttrs = null;
            if (isInline) {
                // set up inline image object attributes and store it in a hashmap
                InlineImage inImg = new InlineImage(buffImg, image != null ? image.getFileType() : "png");
                imageAttrs = new RenderedImageInline(inlineImageCounter, inImg, numPage, flip, rotate);
            } else {
                // set up image object for normal images
                imageAttrs = new RenderedImageNormal(numPage, renderInfo.getRef().getNumber(), flip, rotate);
            }

            // scaling image with original aspect ratio (if image exceded pic box)
            int w = buffImg.getWidth();
            int h = buffImg.getHeight();

            if (w > 170 || h > 170) {
                double faktor;
                if (w > h) {
                    faktor = 160 / (double) w;
                    int scaledW = (int) Math.round(faktor * w);
                    int scaledH = (int) Math.round(faktor * h);
                    buffImg = PdfTrickUtils.getScaledImagWithScalr(buffImg, scaledW, scaledH);

                } else {
                    faktor = 160 / (double) h;
                    int scaledW = (int) Math.round(faktor * w);
                    int scaledH = (int) Math.round(faktor * h);
                    buffImg = PdfTrickUtils.getScaledImagWithScalr(buffImg, scaledW, scaledH);
                }
            }
            numImg++;
            // dynamic update on the center panel (under EDT thread). UpdatePanelCenter upPcenter = this.upPcenter;
            upPcenter.setInlineImg(isInline);
            upPcenter.setBuffImg(buffImg);
            upPcenter.setImageAttrs(imageAttrs);
            try {
                SwingUtilities.invokeAndWait(upPcenter);
            } catch (InterruptedException e) {
                logger.error("Exception", e);
            } catch (InvocationTargetException e) {
                logger.error("Exception", e);
            }
            buffImg.flush();
        } else {
            unsupportedImage++;
        }
    } catch (IOException e) {
        logger.error("Exception", e);
        PdfTrickMessages.append("ERROR", Consts.SENDLOG_MSG);
        unsupportedImage++;
    } catch (Exception e) {
        logger.error("Exception", e);
        PdfTrickMessages.append("ERROR", Consts.SENDLOG_MSG);
        unsupportedImage++;
    }
}

From source file:org.gmdev.pdftrick.engine.ImagesExtractor.java

License:Open Source License

/**
 * /*from ww w.ja  v  a2  s.com*/
 * @param timeDirResult
 * @param resultFilePath
 * @param imageSelected
 * @param inlineImgSelected
 * @return TRUE if the extraction went good
 */
private boolean extractImgSel(String timeDirResult, String resultFilePath,
        HashMap<String, RenderedImageAttributes> imageSelected,
        HashMap<String, RenderedImageAttributes> inlineImgSelected) {

    final Properties messages = factory.getMessages();
    String result = timeDirResult + "/" + "Img_%s.%s";
    PdfReader reader = null;
    boolean retExtract = true;

    try {
        reader = new PdfReader(resultFilePath);
        Set<String> keys = imageSelected.keySet();
        Iterator<String> i = keys.iterator();
        int z = 1;
        while (i.hasNext()) {
            BufferedImage buff = null;
            String key = i.next();
            RenderedImageAttributes imgAttr = imageSelected.get(key);
            String flip = imgAttr.getFlip();
            String rotate = imgAttr.getRotate();
            int ref = imgAttr.getReference();

            PdfObject o = reader.getPdfObject(ref);
            PdfStream stream = (PdfStream) o;
            PdfImageObject io = null;
            try {
                io = new PdfImageObject((PRStream) stream);
            } catch (UnsupportedPdfException updfe) {
                try {
                    buff = CustomExtraImgReader.readIndexedPNG(ref, resultFilePath);
                    buff = PdfTrickUtils.adjustImage(buff, flip, rotate);
                    String type = "png";
                    String filename = String.format(result, z, type);
                    File outputfile = new File(filename);
                    ImageIO.write(buff, type, outputfile);
                } catch (Exception e) {
                    logger.error("Exception", e);
                    PdfTrickMessages.append("ERROR", Consts.SENDLOG_MSG);
                }
            }

            if (io != null) {
                String type = io.getFileType();
                String filename = String.format(result, z, type);
                BufferedImage buffPic = null;
                try {
                    if (type.equalsIgnoreCase("JBIG2")) {
                        buffPic = CustomExtraImgReader.readJBIG2(io);
                    } else {
                        buffPic = io.getBufferedImage();
                    }
                } catch (IIOException e) {
                    byte[] imageByteArray = io.getImageAsBytes();
                    try {
                        buffPic = CustomExtraImgReader.readCMYK_JPG(imageByteArray);
                    } catch (Exception ex) {
                        logger.error("Exception", e);
                        PdfTrickMessages.append("ERROR", Consts.SENDLOG_MSG);
                    }
                }

                // check if image contains a mask image
                BufferedImage buffMask = null;
                PdfDictionary imageDictionary = io.getDictionary();
                PRStream maskStream = (PRStream) imageDictionary.getAsStream(PdfName.SMASK);

                if (maskStream != null) {
                    // i have an smask object i check that is not a jpeg format, because this may cause some problem on offscreen rendering
                    // usually all imges with mask are png ... and there aren't problem, if image is jpg i discard the mask :)
                    if (!type.equalsIgnoreCase("jpg")) {
                        PdfImageObject maskImage = new PdfImageObject(maskStream);
                        buffMask = maskImage.getBufferedImage();

                        Image img = PdfTrickUtils.TransformGrayToTransparency(buffMask);
                        buff = PdfTrickUtils.ApplyTransparency(buffPic, img);
                    } else {
                        buff = buffPic;
                    }
                } else {
                    buff = buffPic;
                }

                if (buff != null) {
                    buff = PdfTrickUtils.adjustImage(buff, flip, rotate);

                    //particular cases of encoding
                    String encode = "";
                    if (type.equalsIgnoreCase("jp2")) {
                        encode = "jpeg 2000";
                    } else if (type.equalsIgnoreCase("jbig2")) {
                        encode = "jpeg";
                        filename = String.format(result, z, "jpg");
                    } else {
                        encode = type;
                    }

                    File outputfile = new File(filename);
                    ImageIO.write(buff, encode, outputfile);
                }
            }
            z++;
        }
        reader.close();
        if (inlineImgSelected.size() > 0) {
            extractInlineImgSel(timeDirResult, inlineImgSelected, z);
        }
        PdfTrickMessages.append("INFO", messages.getProperty("tmsg_19"));
    } catch (Exception e) {
        logger.error("Exception", e);
        PdfTrickMessages.append("ERROR", Consts.SENDLOG_MSG);
        retExtract = false;
    }
    return retExtract;
}

From source file:org.gmdev.pdftrick.utils.CustomExtraImgReader.java

License:Open Source License

/**
 * Read a png image with if all other method fails
 * @param ref//from w  ww .  j a  v  a2 s.  co m
 * @param resultFile
 * @return The BufferedImage obj
 * @throws IOException
 * @throws ImageReadException
 */
public static BufferedImage readIndexedPNG(int ref, String resultFile) throws IOException, ImageReadException {

    PdfReader reader = new PdfReader(resultFile);
    PRStream stream = (PRStream) reader.getPdfObject(ref);
    PdfDictionary dic = stream;
    byte[] content = PdfReader.getStreamBytesRaw(stream);

    int width = dic.getAsNumber(PdfName.WIDTH).intValue();
    int height = dic.getAsNumber(PdfName.HEIGHT).intValue();
    int pngBitDepth = dic.getAsNumber(PdfName.BITSPERCOMPONENT).intValue();

    PdfObject colorspace = dic.getDirectObject(PdfName.COLORSPACE);
    PdfArray decode = dic.getAsArray(PdfName.DECODE);
    PdfArray carray = (PdfArray) colorspace;
    PdfObject id2 = carray.getDirectObject(3);

    byte[] palette = null;
    if (id2 instanceof PdfString) {
        palette = ((PdfString) id2).getBytes();
    } else if (id2 instanceof PRStream) {
        palette = PdfReader.getStreamBytes(((PRStream) id2));
    }

    Map<PdfName, FilterHandlers.FilterHandler> handlers = new HashMap<PdfName, FilterHandlers.FilterHandler>(
            FilterHandlers.getDefaultFilterHandlers());
    byte[] imageBytes = PdfReader.decodeBytes(content, dic, handlers);

    int stride = (width * pngBitDepth + 7) / 8;
    ByteArrayOutputStream ms = new ByteArrayOutputStream();
    PngWriter png = new PngWriter(ms);

    if (decode != null) {
        if (pngBitDepth == 1) {
            // if the decode array is 1,0, then we need to invert the image
            if (decode.getAsNumber(0).intValue() == 1 && decode.getAsNumber(1).intValue() == 0) {
                int len = imageBytes.length;
                for (int t = 0; t < len; ++t) {
                    imageBytes[t] ^= 0xff;
                }
            } else {
                // if the decode array is 0,1, do nothing.  It's possible that the array could be 0,0 or 1,1 - but that would be silly, so we'll just ignore that case
            }
        } else {
            // todo: add decode transformation for other depths
        }
    }
    int pngColorType = 0;
    png.writeHeader(width, height, pngBitDepth, pngColorType);

    if (palette != null) {
        png.writePalette(palette);
    }
    png.writeData(imageBytes, stride);
    png.writeEnd();

    imageBytes = ms.toByteArray();

    InputStream in = new ByteArrayInputStream(imageBytes);
    ImageInputStream ima_stream = ImageIO.createImageInputStream(in);

    BufferedImage buffImg = null;
    BufferedImage buffPic = ImageIO.read(ima_stream);

    // check if image contains a mask image ... experimental for this type of image
    BufferedImage buffMask = null;
    PRStream maskStream = (PRStream) dic.getAsStream(PdfName.SMASK);
    if (maskStream != null) {
        PdfImageObject maskImage = new PdfImageObject(maskStream);
        buffMask = maskImage.getBufferedImage();

        Image img = PdfTrickUtils.TransformGrayToTransparency(buffMask);
        buffImg = PdfTrickUtils.ApplyTransparency(buffPic, img);
    } else {
        buffImg = buffPic;
    }

    reader.close();
    ms.close();
    in.close();
    return buffImg;
}

From source file:org.h819.commons.file.MyPDFUtils.java

/**
 *  pdf ? pdf//from  www . j a  va 2  s  .  com
 *
 * @param srcPdf      the original PDF
 * @param destPdf     the resulting PDF
 * @param imageFactor The multiplication factor for the image (?  imageFacto =0.5f)
 * @throws IOException
 * @throws DocumentException
 */
public static void compressPdf(File srcPdf, File destPdf, float imageFactor)
        throws IOException, DocumentException {

    PdfReader reader = new PdfReader(srcPdf.getAbsolutePath());
    int n = reader.getXrefSize();
    PdfObject object;
    PRStream stream;
    // Look for image and manipulate image stream
    for (int i = 0; i < n; i++) {
        object = reader.getPdfObject(i);
        if (object == null || !object.isStream())
            continue;
        stream = (PRStream) object;
        if (!PdfName.IMAGE.equals(stream.getAsName(PdfName.SUBTYPE)))
            continue;
        if (!PdfName.DCTDECODE.equals(stream.getAsName(PdfName.FILTER)))
            continue;
        PdfImageObject image = new PdfImageObject(stream);
        BufferedImage bi = image.getBufferedImage();
        if (bi == null)
            continue;
        int width = (int) (bi.getWidth() * imageFactor);
        int height = (int) (bi.getHeight() * imageFactor);
        if (width <= 0 || height <= 0)
            continue;
        BufferedImage img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        AffineTransform at = AffineTransform.getScaleInstance(imageFactor, imageFactor);
        Graphics2D g = img.createGraphics();
        g.drawRenderedImage(bi, at);
        ByteArrayOutputStream imgBytes = new ByteArrayOutputStream();
        ImageIO.write(img, "JPG", imgBytes);
        stream.clear();
        stream.setData(imgBytes.toByteArray(), false, PRStream.NO_COMPRESSION);
        stream.put(PdfName.TYPE, PdfName.XOBJECT);
        stream.put(PdfName.SUBTYPE, PdfName.IMAGE);
        stream.put(PdfName.FILTER, PdfName.DCTDECODE);
        stream.put(PdfName.WIDTH, new PdfNumber(width));
        stream.put(PdfName.HEIGHT, new PdfNumber(height));
        stream.put(PdfName.BITSPERCOMPONENT, new PdfNumber(8));
        stream.put(PdfName.COLORSPACE, PdfName.DEVICERGB);
    }
    reader.removeUnusedObjects();
    // Save altered PDF
    PdfStamper stamper = new PdfStamper(reader, new FileOutputStream(destPdf.getAbsolutePath()));
    stamper.setFullCompression();
    stamper.close();
    reader.close();
}