apache poi ppt到png emf

Question

我想問一下圖書館APACHE POI。 我有一個.pptx文件，並通過在互聯網上找到的示例將每個幻燈片分成了單獨的圖像。 當幻燈片包含.png，.jpeg圖像時，此方法效果很好，但是一旦幻燈片中包含.emf文件，此圖像就會消失。 所以我想擁有相同的幻燈片副本，但也要帶有.emf文件。 這可能嗎？

版本：Apache POI 3.12

非常感謝

Answer 1

如評論中所述，開箱即用不支持EMF ...並且FreeHep決定擁有LGPL許可證，因此我們不太可能將其包含在發行版中 。

在POI中，基本上有兩個選項可提供自定義圖像渲染器：

• 通過setRenderingHint(Drawable.IMAGE_RENDERER, new MyImageRendener())在Graphics2D上下文中實現並注冊ImageRenderer實現。 缺點是，任何圖像都將調用它，並且您松開了位圖/ wmf圖像的默認處理
• 或提供一個自定義DrawFactory來提供您自己的DrawPictureShape實現-如以下示例所示-僅在必要時轉移到EMF渲染器
  （ 在此示例中，當前的POI ImageRenderer處理看起來並不靈活，而不是具有全局處理程序，可能最好為每個內容類型注冊一個處理程序... ）

除了常用的POI組件之外，我還包括freehep-graphics2d ， freehep-graphicsbase ， freehep-graphicsio ， freehep-graphicsio-emf和freehep-io 。

該示例遠未完成，但我想您至少可以從一個開始：

package org.apache.poi.xslf;

import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.Insets;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

import javax.imageio.ImageIO;

import org.apache.poi.sl.draw.DrawFactory;
import org.apache.poi.sl.draw.DrawPictureShape;
import org.apache.poi.sl.draw.Drawable;
import org.apache.poi.sl.draw.ImageRenderer;
import org.apache.poi.sl.usermodel.PictureData;
import org.apache.poi.sl.usermodel.PictureData.PictureType;
import org.apache.poi.sl.usermodel.PictureShape;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
import org.apache.poi.xslf.usermodel.XMLSlideShow;
import org.apache.poi.xslf.usermodel.XSLFPictureShape;
import org.apache.poi.xslf.usermodel.XSLFSlide;
import org.freehep.graphicsio.emf.EMFInputStream;
import org.freehep.graphicsio.emf.EMFRenderer;
import org.junit.Test;

public class TestEMFRender {
    private final static POILogger LOG = POILogFactory.getLogger(TestEMFRender.class);

    @Test
    public void render() throws Exception {
        XMLSlideShow ppt = getDummy();

        Dimension pgsize = ppt.getPageSize();
        BufferedImage img = new BufferedImage((int)pgsize.getWidth(), (int)pgsize.getHeight(), BufferedImage.TYPE_INT_ARGB);
        Graphics2D graphics = initGraphicsCtx(img);

        // draw stuff
        ppt.getSlides().get(0).draw(graphics);

        // save the result
        File outfile = new File("bla.png");
        ImageIO.write(img, "PNG", outfile);

        // cleanup
        graphics.dispose();
        img.flush();
        ppt.close();
    }

    static XMLSlideShow getDummy() throws IOException {
        XMLSlideShow ppt = new XMLSlideShow();
        FileInputStream fis = new FileInputStream("kiwilogo.emf");
        PictureData pd = ppt.addPicture(fis, PictureType.EMF);
        fis.close();
        XSLFSlide sl = ppt.createSlide();
        XSLFPictureShape ps = sl.createPicture(pd);
        ps.setAnchor(new Rectangle2D.Double(100, 100, 100, 100));
        return ppt;
    }

    static Graphics2D initGraphicsCtx(BufferedImage img) {
        Graphics2D graphics = img.createGraphics();
        // default rendering options
        graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        graphics.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
        graphics.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);

        // custom draw factory
        DrawFactory df = new DrawFactory(){
            public DrawPictureShape getDrawable(PictureShape<?,?> shape) {
                return new DrawPictureShapeEmf(shape);
            }
        };
        graphics.setRenderingHint(Drawable.DRAW_FACTORY, df);

        df.fixFonts(graphics);

        return graphics;
    }

    static class DrawPictureShapeEmf extends DrawPictureShape {
        public DrawPictureShapeEmf(PictureShape<?,?> shape) {
            super(shape);
        }


        @Override
        public void drawContent(Graphics2D graphics) {
            PictureData data = getShape().getPictureData();
            if(data == null) return;

            Rectangle2D anchor = getAnchor(graphics, getShape());
            Insets insets = getShape().getClipping();

            try {
                String contentType = data.getContentType();
                ImageRenderer renderer =
                    PictureType.EMF.contentType.equals(contentType)
                    ? new ImgRenderer()
                    : super.getImageRenderer(graphics, contentType);

                renderer.loadImage(data.getData(), data.getContentType());
                renderer.drawImage(graphics, anchor, insets);
            } catch (IOException e) {
                LOG.log(POILogger.ERROR, "image can't be loaded/rendered.", e);
            }
        }

    }


    static class ImgRenderer implements ImageRenderer {
        EMFRenderer emfRenderer;

        public void loadImage(InputStream data, String contentType) throws IOException {
            emfRenderer = new EMFRenderer(new EMFInputStream(data));
        }

        public void loadImage(byte[] data, String contentType) throws IOException {
            loadImage(new ByteArrayInputStream(data), contentType);
        }

        public Dimension getDimension() {
            return emfRenderer.getSize();
        }

        public void setAlpha(double alpha) {
        }

        public BufferedImage getImage() {
            return null;
        }

        public BufferedImage getImage(Dimension dim) {
            return null;
        }

        public boolean drawImage(Graphics2D ctx, Rectangle2D graphicsBounds) {
            return drawImage(ctx, graphicsBounds, null);
        }

        public boolean drawImage(Graphics2D ctx, Rectangle2D graphicsBounds, Insets clip) {
            AffineTransform at = ctx.getTransform();
            try {
                Dimension emfDim = emfRenderer.getSize();
                // scale output bounds to image bounds
                ctx.translate(graphicsBounds.getX(), graphicsBounds.getY());
                ctx.scale(graphicsBounds.getWidth()/emfDim.getWidth(), graphicsBounds.getHeight()/emfDim.getHeight());

                // TODO: handle clipping

                emfRenderer.paint(ctx);

                return true;
            } catch (RuntimeException e) {
                // TODO: logging
                return false;
            } finally {
                ctx.setTransform(at);
            }
        }

    }
}