org.apache.poi.xslf.draw.SVGRenderExtension Maven / Gradle / Ivy
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.xslf.draw;
import static java.awt.MultipleGradientPaint.ColorSpaceType.LINEAR_RGB;
import static org.apache.batik.svggen.SVGSyntax.ID_PREFIX_IMAGE;
import static org.apache.batik.svggen.SVGSyntax.ID_PREFIX_PATTERN;
import static org.apache.batik.svggen.SVGSyntax.SIGN_POUND;
import static org.apache.batik.svggen.SVGSyntax.URL_PREFIX;
import static org.apache.batik.svggen.SVGSyntax.URL_SUFFIX;
import static org.apache.batik.util.SVGConstants.*;
import static org.apache.poi.sl.usermodel.PictureData.PictureType.GIF;
import static org.apache.poi.sl.usermodel.PictureData.PictureType.JPEG;
import static org.apache.poi.sl.usermodel.PictureData.PictureType.PNG;
import java.awt.Color;
import java.awt.LinearGradientPaint;
import java.awt.MultipleGradientPaint;
import java.awt.Paint;
import java.awt.RadialGradientPaint;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.TexturePaint;
import java.awt.geom.AffineTransform;
import java.awt.geom.Dimension2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.WritableRaster;
import java.io.IOException;
import java.lang.ref.WeakReference;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import java.util.zip.CRC32;
import javax.imageio.ImageIO;
import org.apache.batik.svggen.DefaultExtensionHandler;
import org.apache.batik.svggen.SVGColor;
import org.apache.batik.svggen.SVGGeneratorContext;
import org.apache.batik.svggen.SVGGraphics2D;
import org.apache.batik.svggen.SVGPaintDescriptor;
import org.apache.batik.svggen.SVGTexturePaint;
import org.apache.commons.io.output.UnsynchronizedByteArrayOutputStream;
import org.apache.poi.sl.draw.BitmapImageRenderer;
import org.apache.poi.sl.draw.DrawTexturePaint;
import org.apache.poi.sl.draw.Drawable;
import org.apache.poi.sl.draw.ImageRenderer;
import org.apache.poi.sl.draw.PathGradientPaint;
import org.apache.poi.sl.draw.PathGradientPaint.PathGradientContext;
import org.apache.poi.sl.usermodel.Insets2D;
import org.apache.poi.sl.usermodel.PaintStyle;
import org.apache.poi.sl.usermodel.SimpleShape;
import org.apache.poi.util.Dimension2DDouble;
import org.apache.poi.util.Internal;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
/**
* Extension of Batik's DefaultExtensionHandler which handles different kinds of Paint objects
*
* Taken (with permission) from https://gist.github.com/msteiger/4509119,
* including the fixes that are discussed in the comments
*
* @see BATIK-1032
*/
@Internal
public class SVGRenderExtension extends DefaultExtensionHandler {
private static final int LINE_LENGTH = 65;
private static final String XLINK_NS = "http://www.w3.org/1999/xlink";
private final Map imageMap = new HashMap<>();
private WeakReference svgGraphics2D = null;
public SVGGraphics2D getSvgGraphics2D() {
return (svgGraphics2D != null) ? svgGraphics2D.get() : null;
}
public void setSvgGraphics2D(SVGGraphics2D svgGraphics2D) {
this.svgGraphics2D = new WeakReference<>(svgGraphics2D);
}
@Override
public SVGPaintDescriptor handlePaint(Paint paint, SVGGeneratorContext generatorContext) {
if (paint instanceof LinearGradientPaint) {
return getLgpDescriptor((LinearGradientPaint)paint, generatorContext);
}
if (paint instanceof RadialGradientPaint) {
return getRgpDescriptor((RadialGradientPaint)paint, generatorContext);
}
if (paint instanceof PathGradientPaint) {
return getPathDescriptor((PathGradientPaint)paint, generatorContext);
}
if (paint instanceof DrawTexturePaint) {
return getDtpDescriptor((DrawTexturePaint)paint, generatorContext);
}
return super.handlePaint(paint, generatorContext);
}
private SVGPaintDescriptor getPathDescriptor(PathGradientPaint gradient, SVGGeneratorContext genCtx) {
RenderingHints hints = genCtx.getGraphicContextDefaults().getRenderingHints();
Shape shape = (Shape)hints.get(Drawable.GRADIENT_SHAPE);
if (shape == null) {
return null;
}
PathGradientContext context = gradient.createContext(ColorModel.getRGBdefault(), shape.getBounds(), shape.getBounds2D(), new AffineTransform(), hints);
WritableRaster raster = context.createRaster();
BufferedImage img = new BufferedImage(context.getColorModel(), raster, false, null);
SVGTexturePaint texturePaint = new SVGTexturePaint(genCtx);
TexturePaint tp = new TexturePaint(img, shape.getBounds2D());
return texturePaint.toSVG(tp);
}
private SVGPaintDescriptor getRgpDescriptor(RadialGradientPaint gradient, SVGGeneratorContext genCtx) {
Element gradElem = genCtx.getDOMFactory().createElementNS(SVG_NAMESPACE_URI, SVG_RADIAL_GRADIENT_TAG);
// Create and set unique XML id
String id = genCtx.getIDGenerator().generateID("gradient");
gradElem.setAttribute(SVG_ID_ATTRIBUTE, id);
// Set x,y pairs
setPoint(gradElem, gradient.getCenterPoint(), "cx", "cy");
setPoint(gradElem, gradient.getFocusPoint(), "fx", "fy");
gradElem.setAttribute("r", String.valueOf(gradient.getRadius()));
addMgpAttributes(gradElem, genCtx, gradient);
return new SVGPaintDescriptor("url(#" + id + ")", SVG_OPAQUE_VALUE, gradElem);
}
private SVGPaintDescriptor getLgpDescriptor(LinearGradientPaint gradient, SVGGeneratorContext genCtx) {
Element gradElem = genCtx.getDOMFactory().createElementNS(SVG_NAMESPACE_URI, SVG_LINEAR_GRADIENT_TAG);
// Create and set unique XML id
String id = genCtx.getIDGenerator().generateID("gradient");
gradElem.setAttribute(SVG_ID_ATTRIBUTE, id);
// Set x,y pairs
setPoint(gradElem, gradient.getStartPoint(), "x1", "y1");
setPoint(gradElem, gradient.getEndPoint(), "x2", "y2");
addMgpAttributes(gradElem, genCtx, gradient);
return new SVGPaintDescriptor("url(#" + id + ")", SVG_OPAQUE_VALUE, gradElem);
}
private void addMgpAttributes(Element gradElem, SVGGeneratorContext genCtx, MultipleGradientPaint gradient) {
gradElem.setAttribute(SVG_GRADIENT_UNITS_ATTRIBUTE, SVG_USER_SPACE_ON_USE_VALUE);
// Set cycle method
final String cycleVal;
switch (gradient.getCycleMethod()) {
case REFLECT:
cycleVal = SVG_REFLECT_VALUE;
break;
case REPEAT:
cycleVal = SVG_REPEAT_VALUE;
break;
case NO_CYCLE:
default:
cycleVal = SVG_PAD_VALUE;
break;
}
gradElem.setAttribute(SVG_SPREAD_METHOD_ATTRIBUTE, cycleVal);
// Set color space
final String colorSpace = (gradient.getColorSpace() == LINEAR_RGB) ? SVG_LINEAR_RGB_VALUE : SVG_SRGB_VALUE;
gradElem.setAttribute(SVG_COLOR_INTERPOLATION_ATTRIBUTE, colorSpace);
// Set transform matrix if not identity
AffineTransform tf = gradient.getTransform();
if (!tf.isIdentity()) {
String matrix = "matrix(" + tf.getScaleX() + " " + tf.getShearY()
+ " " + tf.getShearX() + " " + tf.getScaleY() + " "
+ tf.getTranslateX() + " " + tf.getTranslateY() + ")";
gradElem.setAttribute(SVG_GRADIENT_TRANSFORM_ATTRIBUTE, matrix);
}
// Convert gradient stops
final Color[] colors = gradient.getColors();
final float[] fracs = gradient.getFractions();
for (int i = 0; i < colors.length; i++) {
Element stop = genCtx.getDOMFactory().createElementNS(SVG_NAMESPACE_URI, SVG_STOP_TAG);
SVGPaintDescriptor pd = SVGColor.toSVG(colors[i], genCtx);
stop.setAttribute(SVG_OFFSET_ATTRIBUTE, (int) (fracs[i] * 100.0f) + "%");
stop.setAttribute(SVG_STOP_COLOR_ATTRIBUTE, pd.getPaintValue());
if (colors[i].getAlpha() != 255) {
stop.setAttribute(SVG_STOP_OPACITY_ATTRIBUTE, pd.getOpacityValue());
}
gradElem.appendChild(stop);
}
}
private static void setPoint(Element gradElem, Point2D point, String x, String y) {
gradElem.setAttribute(x, Double.toString(point.getX()));
gradElem.setAttribute(y, Double.toString(point.getY()));
}
private SVGPaintDescriptor getDtpDescriptor(DrawTexturePaint tdp, SVGGeneratorContext genCtx) {
String imgID = getImageID(tdp, genCtx);
Document domFactory = genCtx.getDOMFactory();
Element patternDef = domFactory.createElementNS(SVG_NAMESPACE_URI, SVG_PATTERN_TAG);
String patID = genCtx.getIDGenerator().generateID(ID_PREFIX_PATTERN);
PaintStyle.TexturePaint fill = tdp.getFill();
Insets2D stretch = fill.getStretch();
if (stretch == null) {
stretch = new Insets2D(0,0,0,0);
}
Rectangle2D anchorRect = tdp.getAnchorRect();
String x = genCtx.doubleString(-stretch.left/100_000 * anchorRect.getWidth());
String y = genCtx.doubleString(-stretch.top/100_000 * anchorRect.getHeight());
String w = genCtx.doubleString((100_000+stretch.left+stretch.right)/100_000 * anchorRect.getWidth());
String h = genCtx.doubleString((100_000+stretch.top+stretch.bottom)/100_000 * anchorRect.getHeight());
Dimension2D scale = fill.getScale();
if (scale == null) {
scale = new Dimension2DDouble(1,1);
}
Point2D offset = fill.getOffset();
if (offset == null) {
offset = new Point2D.Double(0,0);
}
PaintStyle.FlipMode flipMode = fill.getFlipMode();
if (flipMode == null) {
flipMode = PaintStyle.FlipMode.NONE;
}
setAttribute(genCtx, patternDef,
null, SVG_PATTERN_UNITS_ATTRIBUTE, SVG_OBJECT_BOUNDING_BOX_VALUE,
null, SVG_ID_ATTRIBUTE, patID,
null, SVG_X_ATTRIBUTE, offset.getX(),
null, SVG_Y_ATTRIBUTE, offset.getY(),
null, SVG_WIDTH_ATTRIBUTE, genCtx.doubleString(scale.getWidth()*100)+"%",
null, SVG_HEIGHT_ATTRIBUTE, genCtx.doubleString(scale.getHeight()*100)+"%",
null, SVG_PRESERVE_ASPECT_RATIO_ATTRIBUTE, SVG_NONE_VALUE,
null, SVG_VIEW_BOX_ATTRIBUTE, x+" "+ y+" "+ w+" "+h
);
org.apache.poi.sl.usermodel.Shape slShape = fill.getShape();
// TODO: the rotation handling is incomplete and the scale handling is missing
// see DrawTexturePaint on how to do it for AWT
if (!fill.isRotatedWithShape() && slShape instanceof SimpleShape) {
double rot = ((SimpleShape)slShape).getRotation();
if (rot != 0) {
setAttribute(genCtx, patternDef,
null, SVG_PATTERN_TRANSFORM_ATTRIBUTE, "rotate(" + genCtx.doubleString(-rot) + ")");
}
}
Element useImageEl = domFactory.createElementNS(SVG_NAMESPACE_URI, SVG_USE_TAG);
useImageEl.setAttributeNS(null, "href", "#"+imgID);
patternDef.appendChild(useImageEl);
String patternAttrBuf = URL_PREFIX + SIGN_POUND + patID + URL_SUFFIX;
return new SVGPaintDescriptor(patternAttrBuf, SVG_OPAQUE_VALUE, patternDef);
}
private String getImageID(DrawTexturePaint tdp, SVGGeneratorContext genCtx) {
final ImageRenderer imgRdr = tdp.getImageRenderer();
byte[] imgData = null;
String contentType = null;
if (imgRdr instanceof BitmapImageRenderer) {
BitmapImageRenderer bir = (BitmapImageRenderer)imgRdr;
String ct = bir.getCachedContentType();
if (PNG.contentType.equals(ct) ||
JPEG.contentType.equals(ct) ||
GIF.contentType.equals(ct)) {
contentType = ct;
imgData = bir.getCachedImage();
}
}
if (imgData == null) {
BufferedImage bi = imgRdr.getImage();
UnsynchronizedByteArrayOutputStream bos = UnsynchronizedByteArrayOutputStream.builder().get();
try {
ImageIO.write(bi, "PNG", bos);
} catch (IOException e) {
return null;
}
imgData = bos.toByteArray();
contentType = PNG.contentType;
}
CRC32 crc = new CRC32();
crc.update(imgData);
Long imageCrc = crc.getValue();
String imgID = imageMap.get(imageCrc);
if (imgID != null) {
return imgID;
}
Document domFactory = genCtx.getDOMFactory();
Rectangle2D anchorRect = tdp.getAnchorRect();
imgID = genCtx.getIDGenerator().generateID(ID_PREFIX_IMAGE);
imageMap.put(imageCrc, imgID);
// length of a base64 string
int sbLen = ((4 * imgData.length / 3) + 3) & ~3;
// add line breaks every 65 chars and a few more padding chars
sbLen += sbLen / LINE_LENGTH + 30;
StringBuilder sb = new StringBuilder(sbLen);
sb.append("data:");
sb.append(contentType);
sb.append(";base64,\n");
sb.append(Base64.getMimeEncoder(LINE_LENGTH, "\n".getBytes(StandardCharsets.US_ASCII)).encodeToString(imgData));
Element imageEl = domFactory.createElementNS(SVG_NAMESPACE_URI, SVG_IMAGE_TAG);
setAttribute(genCtx, imageEl,
null, SVG_ID_ATTRIBUTE, imgID,
null, SVG_PRESERVE_ASPECT_RATIO_ATTRIBUTE, SVG_NONE_VALUE,
null, SVG_X_ATTRIBUTE, anchorRect.getX(),
null, SVG_Y_ATTRIBUTE, anchorRect.getY(),
null, SVG_WIDTH_ATTRIBUTE, anchorRect.getWidth(),
null, SVG_HEIGHT_ATTRIBUTE, anchorRect.getHeight(),
XLINK_NS, "xlink:href", sb.toString()
);
getSvgGraphics2D().getDOMTreeManager().addOtherDef(imageEl);
return imgID;
}
private static void setAttribute(SVGGeneratorContext genCtx, Element el, Object... params) {
for (int i=0; i