package processing.core;
import java.awt.Paint;
import java.awt.PaintContext;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.ColorModel;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
import java.util.HashMap;
import processing.xml.XMLElement;
/**
* SVG stands for Scalable Vector Graphics, a portable graphics format. It is
* a vector format so it allows for infinite resolution and relatively small
* file sizes. Most modern media software can view SVG files, including Adobe
* products, Firefox, etc. Illustrator and Inkscape can edit SVG files.
* <p>
* We have no intention of turning this into a full-featured SVG library.
* The goal of this project is a basic shape importer that is small enough
* to be included with applets, meaning that its download size should be
* in the neighborhood of 25-30k. Starting with release 0149, this library
* has been incorporated into the core via the loadShape() command, because
* vector shape data is just as important as the image data from loadImage().
* <p>
* For more sophisticated import/export, consider the
* <A HREF="http://xmlgraphics.apache.org/batik/">Batik</A>
* library from the Apache Software Foundation. Future improvements to this
* library may focus on this properly supporting a specific subset of SVG,
* for instance the simpler SVG profiles known as
* <A HREF="http://www.w3.org/TR/SVGMobile/">SVG Tiny or Basic</A>,
* although we still would not support the interactivity options.
*
* <p> <hr noshade> <p>
*
* A minimal example program using SVG:
* (assuming a working moo.svg is in your data folder)
*
* <PRE>
* PShape moo;
*
* void setup() {
* size(400, 400);
* moo = loadShape("moo.svg");
* }
* void draw() {
* background(255);
* shape(moo, mouseX, mouseY);
* }
* </PRE>
*
* This code is based on the Candy library written by Michael Chang, which was
* later revised and expanded for use as a Processing core library by Ben Fry.
* Thanks to Ricard Marxer Pinon for help with better Inkscape support in 0154.
*
* <p> <hr noshade> <p>
*
* Late October 2008 revisions from ricardmp, incorporated by fry (0154)
* <UL>
* <LI>Better style attribute handling, enabling better Inkscape support.
* </UL>
*
* October 2008 revisions by fry (Processing 0149, pre-1.0)
* <UL>
* <LI> Candy is no longer a separate library, and is instead part of core.
* <LI> Loading now works through loadShape()
* <LI> Shapes are now drawn using the new PGraphics shape() method.
* </UL>
*
* August 2008 revisions by fry (Processing 0149)
* <UL>
* <LI> Major changes to rework around PShape.
* <LI> Now implementing more of the "transform" attribute.
* </UL>
*
* February 2008 revisions by fry (Processing 0136)
* <UL>
* <LI> Added support for quadratic curves in paths (Q, q, T, and t operators)
* <LI> Support for reading SVG font data (though not rendering it yet)
* </UL>
*
* Revisions for "Candy 2" November 2006 by fry
* <UL>
* <LI> Switch to the new processing.xml library
* <LI> Several bug fixes for parsing of shape data
* <LI> Support for linear and radial gradients
* <LI> Support for additional types of shapes
* <LI> Added compound shapes (shapes with interior points)
* <LI> Added methods to get shapes from an internal table
* </UL>
*
* Revision 10/31/06 by flux
* <UL>
* <LI> Now properly supports Processing 0118
* <LI> Fixed a bunch of things for Casey's students and general buggity.
* <LI> Will now properly draw #FFFFFFFF colors (were being represented as -1)
* <LI> SVGs without <g> tags are now properly caught and loaded
* <LI> Added a method customStyle() for overriding SVG colors/styles
* <LI> Added a method SVGStyle() to go back to using SVG colors/styles
* </UL>
*
* Some SVG objects and features may not yet be supported.
* Here is a partial list of non-included features
* <UL>
* <LI> Rounded rectangles
* <LI> Drop shadow objects
* <LI> Typography
* <LI> <STRIKE>Layers</STRIKE> added for Candy 2
* <LI> Patterns
* <LI> Embedded images
* </UL>
*
* For those interested, the SVG specification can be found
* <A HREF="http://www.w3.org/TR/SVG">here</A>.
*/
public class PShapeSVG extends PShape {
XMLElement element;
float opacity;
float strokeOpacity;
float fillOpacity;
Gradient strokeGradient;
Paint strokeGradientPaint;
String strokeName; // id of another object, gradients only?
Gradient fillGradient;
Paint fillGradientPaint;
String fillName; // id of another object
/**
* Initializes a new SVG Object with the given filename.
*/
public PShapeSVG(PApplet parent, String filename) {
// this will grab the root document, starting <svg ...>
// the xml version and initial comments are ignored
this(new XMLElement(parent, filename));
}
/**
* Initializes a new SVG Object from the given XMLElement.
*/
public PShapeSVG(XMLElement svg) {
this(null, svg);
if (!svg.getName().equals("svg")) {
throw new RuntimeException("root is not <svg>, it's <" + svg.getName() + ">");
}
// not proper parsing of the viewBox, but will cover us for cases where
// the width and height of the object is not specified
String viewBoxStr = svg.getStringAttribute("viewBox");
if (viewBoxStr != null) {
int[] viewBox = PApplet.parseInt(PApplet.splitTokens(viewBoxStr));
width = viewBox[2];
height = viewBox[3];
}
// TODO if viewbox is not same as width/height, then use it to scale
// the original objects. for now, viewbox only used when width/height
// are empty values (which by the spec means w/h of "100%"
String unitWidth = svg.getStringAttribute("width");
String unitHeight = svg.getStringAttribute("height");
if (unitWidth != null) {
width = parseUnitSize(unitWidth);
height = parseUnitSize(unitHeight);
} else {
if ((width == 0) || (height == 0)) {
//throw new RuntimeException("width/height not specified");
PGraphics.showWarning("The width and/or height is not " +
"readable in the <svg> tag of this file.");
// For the spec, the default is 100% and 100%. For purposes
// here, insert a dummy value because this is prolly just a
// font or something for which the w/h doesn't matter.
width = 1;
height = 1;
}
}
//root = new Group(null, svg);
parseChildren(svg); // ?
}
public PShapeSVG(PShapeSVG parent, XMLElement properties) {
//super(GROUP);
if (parent == null) {
// set values to their defaults according to the SVG spec
stroke = false;
strokeColor = 0xff000000;
strokeWeight = 1;
strokeCap = PConstants.SQUARE; // equivalent to BUTT in svg spec
strokeJoin = PConstants.MITER;
strokeGradient = null;
strokeGradientPaint = null;
strokeName = null;
fill = true;
fillColor = 0xff000000;
fillGradient = null;
fillGradientPaint = null;
fillName = null;
//hasTransform = false;
//transformation = null; //new float[] { 1, 0, 0, 1, 0, 0 };
strokeOpacity = 1;
fillOpacity = 1;
opacity = 1;
} else {
stroke = parent.stroke;
strokeColor = parent.strokeColor;
strokeWeight = parent.strokeWeight;
strokeCap = parent.strokeCap;
strokeJoin = parent.strokeJoin;
strokeGradient = parent.strokeGradient;
strokeGradientPaint = parent.strokeGradientPaint;
strokeName = parent.strokeName;
fill = parent.fill;
fillColor = parent.fillColor;
fillGradient = parent.fillGradient;
fillGradientPaint = parent.fillGradientPaint;
fillName = parent.fillName;
//hasTransform = parent.hasTransform;
//transformation = parent.transformation;
opacity = parent.opacity;
}
element = properties;
name = properties.getStringAttribute("id");
String displayStr = properties.getStringAttribute("display", "inline");
visible = !displayStr.equals("none");
String transformStr = properties.getStringAttribute("transform");
if (transformStr != null) {
matrix = parseMatrix(transformStr);
}
parseColors(properties);
parseChildren(properties);
}
protected void parseChildren(XMLElement graphics) {
XMLElement[] elements = graphics.getChildren();
children = new PShape[elements.length];
childCount = 0;
for (XMLElement elem : elements) {
PShape kid = parseChild(elem);
if (kid != null) {
addChild(kid);
}
}
}
/**
* Parse a child XML element.
* Override this method to add parsing for more SVG elements.
*/
protected PShape parseChild(XMLElement elem) {
String name = elem.getName();
PShapeSVG shape = null;
if (name.equals("g")) {
//return new BaseObject(this, elem);
shape = new PShapeSVG(this, elem);
} else if (name.equals("defs")) {
// generally this will contain gradient info, so may
// as well just throw it into a group element for parsing
//return new BaseObject(this, elem);
shape = new PShapeSVG(this, elem);
} else if (name.equals("line")) {
//return new Line(this, elem);
//return new BaseObject(this, elem, LINE);
shape = new PShapeSVG(this, elem);
shape.parseLine();
} else if (name.equals("circle")) {
//return new BaseObject(this, elem, ELLIPSE);
shape = new PShapeSVG(this, elem);
shape.parseEllipse(true);
} else if (name.equals("ellipse")) {
//return new BaseObject(this, elem, ELLIPSE);
shape = new PShapeSVG(this, elem);
shape.parseEllipse(false);
} else if (name.equals("rect")) {
//return new BaseObject(this, elem, RECT);
shape = new PShapeSVG(this, elem);
shape.parseRect();
} else if (name.equals("polygon")) {
//return new BaseObject(this, elem, POLYGON);
shape = new PShapeSVG(this, elem);
shape.parsePoly(true);
} else if (name.equals("polyline")) {
//return new BaseObject(this, elem, POLYGON);
shape = new PShapeSVG(this, elem);
shape.parsePoly(false);
} else if (name.equals("path")) {
//return new BaseObject(this, elem, PATH);
shape = new PShapeSVG(this, elem);
shape.parsePath();
} else if (name.equals("radialGradient")) {
return new RadialGradient(this, elem);
} else if (name.equals("linearGradient")) {
return new LinearGradient(this, elem);
} else if (name.equals("text")) {
PGraphics.showWarning("Text in SVG files is not currently supported, " +
"convert text to outlines instead.");
} else if (name.equals("filter")) {
PGraphics.showWarning("Filters are not supported.");
} else if (name.equals("mask")) {
PGraphics.showWarning("Masks are not supported.");
} else {
PGraphics.showWarning("Ignoring <" + name + "> tag.");
}
return shape;
}
protected void parseLine() {
kind = LINE;
family = PRIMITIVE;
params = new float[] {
element.getFloatAttribute("x1"),
element.getFloatAttribute("y1"),
element.getFloatAttribute("x2"),
element.getFloatAttribute("y2"),
};
// x = params[0];
// y = params[1];
// width = params[2];
// height = params[3];
}
/**
* Handles parsing ellipse and circle tags.
* @param circle true if this is a circle and not an ellipse
*/
protected void parseEllipse(boolean circle) {
kind = ELLIPSE;
family = PRIMITIVE;
params = new float[4];
params[0] = element.getFloatAttribute("cx");
params[1] = element.getFloatAttribute("cy");
float rx, ry;
if (circle) {
rx = ry = element.getFloatAttribute("r");
} else {
rx = element.getFloatAttribute("rx");
ry = element.getFloatAttribute("ry");
}
params[0] -= rx;
params[1] -= ry;
params[2] = rx*2;
params[3] = ry*2;
}
protected void parseRect() {
kind = RECT;
family = PRIMITIVE;
params = new float[] {
element.getFloatAttribute("x"),
element.getFloatAttribute("y"),
element.getFloatAttribute("width"),
element.getFloatAttribute("height"),
};
}
/**
* Parse a polyline or polygon from an SVG file.
* @param close true if shape is closed (polygon), false if not (polyline)
*/
protected void parsePoly(boolean close) {
family = PATH;
this.close = close;
String pointsAttr = element.getStringAttribute("points");
if (pointsAttr != null) {
String[] pointsBuffer = PApplet.splitTokens(pointsAttr);
vertexCount = pointsBuffer.length;
vertices = new float[vertexCount][2];
for (int i = 0; i < vertexCount; i++) {
String pb[] = PApplet.split(pointsBuffer[i], ',');
vertices[i][X] = Float.valueOf(pb[0]).floatValue();
vertices[i][Y] = Float.valueOf(pb[1]).floatValue();
}
}
}
protected void parsePath() {
family = PATH;
kind = 0;
String pathData = element.getStringAttribute("d");
if (pathData == null) return;
char[] pathDataChars = pathData.toCharArray();
StringBuffer pathBuffer = new StringBuffer();
boolean lastSeparate = false;
for (int i = 0; i < pathDataChars.length; i++) {
char c = pathDataChars[i];
boolean separate = false;
if (c == 'M' || c == 'm' ||
c == 'L' || c == 'l' ||
c == 'H' || c == 'h' ||
c == 'V' || c == 'v' ||
c == 'C' || c == 'c' || // beziers
c == 'S' || c == 's' ||
c == 'Q' || c == 'q' || // quadratic beziers
c == 'T' || c == 't' ||
c == 'Z' || c == 'z' || // closepath
c == ',') {
separate = true;
if (i != 0) {
pathBuffer.append("|");
}
}
if (c == 'Z' || c == 'z') {
separate = false;
}
if (c == '-' && !lastSeparate) {
// allow for 'e' notation in numbers, e.g. 2.10e-9
// http://dev.processing.org/bugs/show_bug.cgi?id=1408
if (i == 0 || pathDataChars[i-1] != 'e') {
pathBuffer.append("|");
}
}
if (c != ',') {
pathBuffer.append(c); //"" + pathDataBuffer.charAt(i));
}
if (separate && c != ',' && c != '-') {
pathBuffer.append("|");
}
lastSeparate = separate;
}
// use whitespace constant to get rid of extra spaces and CR or LF
String[] pathDataKeys =
PApplet.splitTokens(pathBuffer.toString(), "|" + WHITESPACE);
vertices = new float[pathDataKeys.length][2];
vertexCodes = new int[pathDataKeys.length];
float cx = 0;
float cy = 0;
int i = 0;
while (i < pathDataKeys.length) {
char c = pathDataKeys[i].charAt(0);
switch (c) {
case 'M': // M - move to (absolute)
cx = PApplet.parseFloat(pathDataKeys[i + 1]);
cy = PApplet.parseFloat(pathDataKeys[i + 2]);
parsePathMoveto(cx, cy);
i += 3;
break;
case 'm': // m - move to (relative)
cx = cx + PApplet.parseFloat(pathDataKeys[i + 1]);
cy = cy + PApplet.parseFloat(pathDataKeys[i + 2]);
parsePathMoveto(cx, cy);
i += 3;
break;
case 'L':
cx = PApplet.parseFloat(pathDataKeys[i + 1]);
cy = PApplet.parseFloat(pathDataKeys[i + 2]);
parsePathLineto(cx, cy);
i += 3;
break;
case 'l':
cx = cx + PApplet.parseFloat(pathDataKeys[i + 1]);
cy = cy + PApplet.parseFloat(pathDataKeys[i + 2]);
parsePathLineto(cx, cy);
i += 3;
break;
// horizontal lineto absolute
case 'H':
cx = PApplet.parseFloat(pathDataKeys[i + 1]);
parsePathLineto(cx, cy);
i += 2;
break;
// horizontal lineto relative
case 'h':
cx = cx + PApplet.parseFloat(pathDataKeys[i + 1]);
parsePathLineto(cx, cy);
i += 2;
break;
case 'V':
cy = PApplet.parseFloat(pathDataKeys[i + 1]);
parsePathLineto(cx, cy);
i += 2;
break;
case 'v':
cy = cy + PApplet.parseFloat(pathDataKeys[i + 1]);
parsePathLineto(cx, cy);
i += 2;
break;
// C - curve to (absolute)
case 'C': {
float ctrlX1 = PApplet.parseFloat(pathDataKeys[i + 1]);
float ctrlY1 = PApplet.parseFloat(pathDataKeys[i + 2]);
float ctrlX2 = PApplet.parseFloat(pathDataKeys[i + 3]);
float ctrlY2 = PApplet.parseFloat(pathDataKeys[i + 4]);
float endX = PApplet.parseFloat(pathDataKeys[i + 5]);
float endY = PApplet.parseFloat(pathDataKeys[i + 6]);
parsePathCurveto(ctrlX1, ctrlY1, ctrlX2, ctrlY2, endX, endY);
cx = endX;
cy = endY;
i += 7;
}
break;
// c - curve to (relative)
case 'c': {
float ctrlX1 = cx + PApplet.parseFloat(pathDataKeys[i + 1]);
float ctrlY1 = cy + PApplet.parseFloat(pathDataKeys[i + 2]);
float ctrlX2 = cx + PApplet.parseFloat(pathDataKeys[i + 3]);
float ctrlY2 = cy + PApplet.parseFloat(pathDataKeys[i + 4]);
float endX = cx + PApplet.parseFloat(pathDataKeys[i + 5]);
float endY = cy + PApplet.parseFloat(pathDataKeys[i + 6]);
parsePathCurveto(ctrlX1, ctrlY1, ctrlX2, ctrlY2, endX, endY);
cx = endX;
cy = endY;
i += 7;
}
break;
// S - curve to shorthand (absolute)
case 'S': {
float ppx = vertices[vertexCount-2][X];
float ppy = vertices[vertexCount-2][Y];
float px = vertices[vertexCount-1][X];
float py = vertices[vertexCount-1][Y];
float ctrlX1 = px + (px - ppx);
float ctrlY1 = py + (py - ppy);
float ctrlX2 = PApplet.parseFloat(pathDataKeys[i + 1]);
float ctrlY2 = PApplet.parseFloat(pathDataKeys[i + 2]);
float endX = PApplet.parseFloat(pathDataKeys[i + 3]);
float endY = PApplet.parseFloat(pathDataKeys[i + 4]);
parsePathCurveto(ctrlX1, ctrlY1, ctrlX2, ctrlY2, endX, endY);
cx = endX;
cy = endY;
i += 5;
}
break;
// s - curve to shorthand (relative)
case 's': {
float ppx = vertices[vertexCount-2][X];
float ppy = vertices[vertexCount-2][Y];
float px = vertices[vertexCount-1][X];
float py = vertices[vertexCount-1][Y];
float ctrlX1 = px + (px - ppx);
float ctrlY1 = py + (py - ppy);
float ctrlX2 = cx + PApplet.parseFloat(pathDataKeys[i + 1]);
float ctrlY2 = cy + PApplet.parseFloat(pathDataKeys[i + 2]);
float endX = cx + PApplet.parseFloat(pathDataKeys[i + 3]);
float endY = cy + PApplet.parseFloat(pathDataKeys[i + 4]);
parsePathCurveto(ctrlX1, ctrlY1, ctrlX2, ctrlY2, endX, endY);
cx = endX;
cy = endY;
i += 5;
}
break;
// Q - quadratic curve to (absolute)
case 'Q': {
float ctrlX = PApplet.parseFloat(pathDataKeys[i + 1]);
float ctrlY = PApplet.parseFloat(pathDataKeys[i + 2]);
float endX = PApplet.parseFloat(pathDataKeys[i + 3]);
float endY = PApplet.parseFloat(pathDataKeys[i + 4]);
parsePathQuadto(cx, cy, ctrlX, ctrlY, endX, endY);
cx = endX;
cy = endY;
i += 5;
}
break;
// q - quadratic curve to (relative)
case 'q': {
float ctrlX = cx + PApplet.parseFloat(pathDataKeys[i + 1]);
float ctrlY = cy + PApplet.parseFloat(pathDataKeys[i + 2]);
float endX = cx + PApplet.parseFloat(pathDataKeys[i + 3]);
float endY = cy + PApplet.parseFloat(pathDataKeys[i + 4]);
parsePathQuadto(cx, cy, ctrlX, ctrlY, endX, endY);
cx = endX;
cy = endY;
i += 5;
}
break;
// T - quadratic curve to shorthand (absolute)
// The control point is assumed to be the reflection of the
// control point on the previous command relative to the
// current point. (If there is no previous command or if the
// previous command was not a Q, q, T or t, assume the control
// point is coincident with the current point.)
case 'T': {
float ppx = vertices[vertexCount-2][X];
float ppy = vertices[vertexCount-2][Y];
float px = vertices[vertexCount-1][X];
float py = vertices[vertexCount-1][Y];
float ctrlX = px + (px - ppx);
float ctrlY = py + (py - ppy);
float endX = PApplet.parseFloat(pathDataKeys[i + 1]);
float endY = PApplet.parseFloat(pathDataKeys[i + 2]);
parsePathQuadto(cx, cy, ctrlX, ctrlY, endX, endY);
cx = endX;
cy = endY;
i += 3;
}
break;
// t - quadratic curve to shorthand (relative)
case 't': {
float ppx = vertices[vertexCount-2][X];
float ppy = vertices[vertexCount-2][Y];
float px = vertices[vertexCount-1][X];
float py = vertices[vertexCount-1][Y];
float ctrlX = px + (px - ppx);
float ctrlY = py + (py - ppy);
float endX = cx + PApplet.parseFloat(pathDataKeys[i + 1]);
float endY = cy + PApplet.parseFloat(pathDataKeys[i + 2]);
parsePathQuadto(cx, cy, ctrlX, ctrlY, endX, endY);
cx = endX;
cy = endY;
i += 3;
}
break;
case 'Z':
case 'z':
close = true;
i++;
break;
default:
String parsed =
PApplet.join(PApplet.subset(pathDataKeys, 0, i), ",");
String unparsed =
PApplet.join(PApplet.subset(pathDataKeys, i), ",");
System.err.println("parsed: " + parsed);
System.err.println("unparsed: " + unparsed);
if (pathDataKeys[i].equals("a") || pathDataKeys[i].equals("A")) {
String msg = "Sorry, elliptical arc support for SVG files " +
"is not yet implemented (See bug #996 for details)";
throw new RuntimeException(msg);
}
throw new RuntimeException("shape command not handled: " + pathDataKeys[i]);
}
}
}
// private void parsePathCheck(int num) {
// if (vertexCount + num-1 >= vertices.length) {
// //vertices = (float[][]) PApplet.expand(vertices);
// float[][] temp = new float[vertexCount << 1][2];
// System.arraycopy(vertices, 0, temp, 0, vertexCount);
// vertices = temp;
// }
// }
private void parsePathVertex(float x, float y) {
if (vertexCount == vertices.length) {
//vertices = (float[][]) PApplet.expand(vertices);
float[][] temp = new float[vertexCount << 1][2];
System.arraycopy(vertices, 0, temp, 0, vertexCount);
vertices = temp;
}
vertices[vertexCount][X] = x;
vertices[vertexCount][Y] = y;
vertexCount++;
}
private void parsePathCode(int what) {
if (vertexCodeCount == vertexCodes.length) {
vertexCodes = PApplet.expand(vertexCodes);
}
vertexCodes[vertexCodeCount++] = what;
}
private void parsePathMoveto(float px, float py) {
if (vertexCount > 0) {
parsePathCode(BREAK);
}
parsePathCode(VERTEX);
parsePathVertex(px, py);
}
private void parsePathLineto(float px, float py) {
parsePathCode(VERTEX);
parsePathVertex(px, py);
}
private void parsePathCurveto(float x1, float y1,
float x2, float y2,
float x3, float y3) {
parsePathCode(BEZIER_VERTEX);
parsePathVertex(x1, y1);
parsePathVertex(x2, y2);
parsePathVertex(x3, y3);
}
private void parsePathQuadto(float x1, float y1,
float cx, float cy,
float x2, float y2) {
parsePathCode(BEZIER_VERTEX);
// x1/y1 already covered by last moveto, lineto, or curveto
parsePathVertex(x1 + ((cx-x1)*2/3.0f), y1 + ((cy-y1)*2/3.0f));
parsePathVertex(x2 + ((cx-x2)*2/3.0f), y2 + ((cy-y2)*2/3.0f));
parsePathVertex(x2, y2);
}
/**
* Parse the specified SVG matrix into a PMatrix2D. Note that PMatrix2D
* is rotated relative to the SVG definition, so parameters are rearranged
* here. More about the transformation matrices in
* <a href="http://www.w3.org/TR/SVG/coords.html#TransformAttribute">this section</a>
* of the SVG documentation.
* @param matrixStr text of the matrix param.
* @return a good old-fashioned PMatrix2D
*/
static protected PMatrix2D parseMatrix(String matrixStr) {
String[] pieces = PApplet.match(matrixStr, "\\s*(\\w+)\\((.*)\\)");
if (pieces == null) {
System.err.println("Could not parse transform " + matrixStr);
return null;
}
float[] m = PApplet.parseFloat(PApplet.splitTokens(pieces[2], ", "));
if (pieces[1].equals("matrix")) {
return new PMatrix2D(m[0], m[2], m[4], m[1], m[3], m[5]);
} else if (pieces[1].equals("translate")) {
float tx = m[0];
float ty = (m.length == 2) ? m[1] : m[0];
//return new float[] { 1, 0, tx, 0, 1, ty };
return new PMatrix2D(1, 0, tx, 0, 1, ty);
} else if (pieces[1].equals("scale")) {
float sx = m[0];
float sy = (m.length == 2) ? m[1] : m[0];
//return new float[] { sx, 0, 0, 0, sy, 0 };
return new PMatrix2D(sx, 0, 0, 0, sy, 0);
} else if (pieces[1].equals("rotate")) {
float angle = m[0];
if (m.length == 1) {
float c = PApplet.cos(angle);
float s = PApplet.sin(angle);
// SVG version is cos(a) sin(a) -sin(a) cos(a) 0 0
return new PMatrix2D(c, -s, 0, s, c, 0);
} else if (m.length == 3) {
PMatrix2D mat = new PMatrix2D(0, 1, m[1], 1, 0, m[2]);
mat.rotate(m[0]);
mat.translate(-m[1], -m[2]);
return mat; //.get(null);
}
} else if (pieces[1].equals("skewX")) {
return new PMatrix2D(1, 0, 1, PApplet.tan(m[0]), 0, 0);
} else if (pieces[1].equals("skewY")) {
return new PMatrix2D(1, 0, 1, 0, PApplet.tan(m[0]), 0);
}
return null;
}
protected void parseColors(XMLElement properties) {
if (properties.hasAttribute("opacity")) {
String opacityText = properties.getStringAttribute("opacity");
setOpacity(opacityText);
}
if (properties.hasAttribute("stroke")) {
String strokeText = properties.getStringAttribute("stroke");
setStroke(strokeText);
}
if (properties.hasAttribute("stroke-width")) {
// if NaN (i.e. if it's 'inherit') then default back to the inherit setting
String lineweight = properties.getStringAttribute("stroke-width");
setStrokeWeight(lineweight);
}
if (properties.hasAttribute("stroke-linejoin")) {
String linejoin = properties.getStringAttribute("stroke-linejoin");
setStrokeJoin(linejoin);
}
if (properties.hasAttribute("stroke-linecap")) {
String linecap = properties.getStringAttribute("stroke-linecap");
setStrokeCap(linecap);
}
// fill defaults to black (though stroke defaults to "none")
// http://www.w3.org/TR/SVG/painting.html#FillProperties
if (properties.hasAttribute("fill")) {
String fillText = properties.getStringAttribute("fill");
setFill(fillText);
}
if (properties.hasAttribute("style")) {
String styleText = properties.getStringAttribute("style");
String[] styleTokens = PApplet.splitTokens(styleText, ";");
//PApplet.println(styleTokens);
for (int i = 0; i < styleTokens.length; i++) {
String[] tokens = PApplet.splitTokens(styleTokens[i], ":");
//PApplet.println(tokens);
tokens[0] = PApplet.trim(tokens[0]);
if (tokens[0].equals("fill")) {
setFill(tokens[1]);
} else if(tokens[0].equals("fill-opacity")) {
setFillOpacity(tokens[1]);
} else if(tokens[0].equals("stroke")) {
setStroke(tokens[1]);
} else if(tokens[0].equals("stroke-width")) {
setStrokeWeight(tokens[1]);
} else if(tokens[0].equals("stroke-linecap")) {
setStrokeCap(tokens[1]);
} else if(tokens[0].equals("stroke-linejoin")) {
setStrokeJoin(tokens[1]);
} else if(tokens[0].equals("stroke-opacity")) {
setStrokeOpacity(tokens[1]);
} else if(tokens[0].equals("opacity")) {
setOpacity(tokens[1]);
} else {
// Other attributes are not yet implemented
}
}
}
}
void setOpacity(String opacityText) {
opacity = PApplet.parseFloat(opacityText);
strokeColor = ((int) (opacity * 255)) << 24 | strokeColor & 0xFFFFFF;
fillColor = ((int) (opacity * 255)) << 24 | fillColor & 0xFFFFFF;
}
void setStrokeWeight(String lineweight) {
strokeWeight = PApplet.parseFloat(lineweight);
}
void setStrokeOpacity(String opacityText) {
strokeOpacity = PApplet.parseFloat(opacityText);
strokeColor = ((int) (strokeOpacity * 255)) << 24 | strokeColor & 0xFFFFFF;
}
void setStroke(String strokeText) {
int opacityMask = strokeColor & 0xFF000000;
if (strokeText.equals("none")) {
stroke = false;
} else if (strokeText.startsWith("#")) {
stroke = true;
strokeColor = opacityMask |
(Integer.parseInt(strokeText.substring(1), 16)) & 0xFFFFFF;
} else if (strokeText.startsWith("rgb")) {
stroke = true;
strokeColor = opacityMask | parseRGB(strokeText);
} else if (strokeText.startsWith("url(#")) {
strokeName = strokeText.substring(5, strokeText.length() - 1);
Object strokeObject = findChild(strokeName);
if (strokeObject instanceof Gradient) {
strokeGradient = (Gradient) strokeObject;
strokeGradientPaint = calcGradientPaint(strokeGradient); //, opacity);
} else {
System.err.println("url " + strokeName + " refers to unexpected data");
}
}
}
void setStrokeJoin(String linejoin) {
if (linejoin.equals("inherit")) {
// do nothing, will inherit automatically
} else if (linejoin.equals("miter")) {
strokeJoin = PConstants.MITER;
} else if (linejoin.equals("round")) {
strokeJoin = PConstants.ROUND;
} else if (linejoin.equals("bevel")) {
strokeJoin = PConstants.BEVEL;
}
}
void setStrokeCap(String linecap) {
if (linecap.equals("inherit")) {
// do nothing, will inherit automatically
} else if (linecap.equals("butt")) {
strokeCap = PConstants.SQUARE;
} else if (linecap.equals("round")) {
strokeCap = PConstants.ROUND;
} else if (linecap.equals("square")) {
strokeCap = PConstants.PROJECT;
}
}
void setFillOpacity(String opacityText) {
fillOpacity = PApplet.parseFloat(opacityText);
fillColor = ((int) (fillOpacity * 255)) << 24 | fillColor & 0xFFFFFF;
}
void setFill(String fillText) {
int opacityMask = fillColor & 0xFF000000;
if (fillText.equals("none")) {
fill = false;
} else if (fillText.startsWith("#")) {
fill = true;
fillColor = opacityMask |
(Integer.parseInt(fillText.substring(1), 16)) & 0xFFFFFF;
//System.out.println("hex for fill is " + PApplet.hex(fillColor));
} else if (fillText.startsWith("rgb")) {
fill = true;
fillColor = opacityMask | parseRGB(fillText);
} else if (fillText.startsWith("url(#")) {
fillName = fillText.substring(5, fillText.length() - 1);
//PApplet.println("looking for " + fillName);
Object fillObject = findChild(fillName);
//PApplet.println("found " + fillObject);
if (fillObject instanceof Gradient) {
fill = true;
fillGradient = (Gradient) fillObject;
fillGradientPaint = calcGradientPaint(fillGradient); //, opacity);
//PApplet.println("got filla " + fillObject);
} else {
System.err.println("url " + fillName + " refers to unexpected data");
}
}
}
static protected int parseRGB(String what) {
int leftParen = what.indexOf('(') + 1;
int rightParen = what.indexOf(')');
String sub = what.substring(leftParen, rightParen);
int[] values = PApplet.parseInt(PApplet.splitTokens(sub, ", "));
return (values[0] << 16) | (values[1] << 8) | (values[2]);
}
static protected HashMap<String, String> parseStyleAttributes(String style) {
HashMap<String, String> table = new HashMap<String, String>();
String[] pieces = style.split(";");
for (int i = 0; i < pieces.length; i++) {
String[] parts = pieces[i].split(":");
table.put(parts[0], parts[1]);
}
return table;
}
/**
* Parse a size that may have a suffix for its units.
* Ignoring cases where this could also be a percentage.
* The <A HREF="http://www.w3.org/TR/SVG/coords.html#Units">units</A> spec:
* <UL>
* <LI>"1pt" equals "1.25px" (and therefore 1.25 user units)
* <LI>"1pc" equals "15px" (and therefore 15 user units)
* <LI>"1mm" would be "3.543307px" (3.543307 user units)
* <LI>"1cm" equals "35.43307px" (and therefore 35.43307 user units)
* <LI>"1in" equals "90px" (and therefore 90 user units)
* </UL>
*/
static protected float parseUnitSize(String text) {
int len = text.length() - 2;
if (text.endsWith("pt")) {
return PApplet.parseFloat(text.substring(0, len)) * 1.25f;
} else if (text.endsWith("pc")) {
return PApplet.parseFloat(text.substring(0, len)) * 15;
} else if (text.endsWith("mm")) {
return PApplet.parseFloat(text.substring(0, len)) * 3.543307f;
} else if (text.endsWith("cm")) {
return PApplet.parseFloat(text.substring(0, len)) * 35.43307f;
} else if (text.endsWith("in")) {
return PApplet.parseFloat(text.substring(0, len)) * 90;
} else if (text.endsWith("px")) {
return PApplet.parseFloat(text.substring(0, len));
} else {
return PApplet.parseFloat(text);
}
}
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
static class Gradient extends PShapeSVG {
AffineTransform transform;
float[] offset;
int[] color;
int count;
public Gradient(PShapeSVG parent, XMLElement properties) {
super(parent, properties);
XMLElement elements[] = properties.getChildren();
offset = new float[elements.length];
color = new int[elements.length];
// <stop offset="0" style="stop-color:#967348"/>
for (int i = 0; i < elements.length; i++) {
XMLElement elem = elements[i];
String name = elem.getName();
if (name.equals("stop")) {
offset[count] = elem.getFloatAttribute("offset");
String style = elem.getStringAttribute("style");
HashMap<String, String> styles = parseStyleAttributes(style);
String colorStr = styles.get("stop-color");
if (colorStr == null) colorStr = "#000000";
String opacityStr = styles.get("stop-opacity");
if (opacityStr == null) opacityStr = "1";
int tupacity = (int) (PApplet.parseFloat(opacityStr) * 255);
color[count] = (tupacity << 24) |
Integer.parseInt(colorStr.substring(1), 16);
count++;
}
}
offset = PApplet.subset(offset, 0, count);
color = PApplet.subset(color, 0, count);
}
}
class LinearGradient extends Gradient {
float x1, y1, x2, y2;
public LinearGradient(PShapeSVG parent, XMLElement properties) {
super(parent, properties);
this.x1 = properties.getFloatAttribute("x1");
this.y1 = properties.getFloatAttribute("y1");
this.x2 = properties.getFloatAttribute("x2");
this.y2 = properties.getFloatAttribute("y2");
String transformStr =
properties.getStringAttribute("gradientTransform");
if (transformStr != null) {
float t[] = parseMatrix(transformStr).get(null);
this.transform = new AffineTransform(t[0], t[3], t[1], t[4], t[2], t[5]);
Point2D t1 = transform.transform(new Point2D.Float(x1, y1), null);
Point2D t2 = transform.transform(new Point2D.Float(x2, y2), null);
this.x1 = (float) t1.getX();
this.y1 = (float) t1.getY();
this.x2 = (float) t2.getX();
this.y2 = (float) t2.getY();
}
}
}
class RadialGradient extends Gradient {
float cx, cy, r;
public RadialGradient(PShapeSVG parent, XMLElement properties) {
super(parent, properties);
this.cx = properties.getFloatAttribute("cx");
this.cy = properties.getFloatAttribute("cy");
this.r = properties.getFloatAttribute("r");
String transformStr =
properties.getStringAttribute("gradientTransform");
if (transformStr != null) {
float t[] = parseMatrix(transformStr).get(null);
this.transform = new AffineTransform(t[0], t[3], t[1], t[4], t[2], t[5]);
Point2D t1 = transform.transform(new Point2D.Float(cx, cy), null);
Point2D t2 = transform.transform(new Point2D.Float(cx + r, cy), null);
this.cx = (float) t1.getX();
this.cy = (float) t1.getY();
this.r = (float) (t2.getX() - t1.getX());
}
}
}
class LinearGradientPaint implements Paint {
float x1, y1, x2, y2;
float[] offset;
int[] color;
int count;
float opacity;
public LinearGradientPaint(float x1, float y1, float x2, float y2,
float[] offset, int[] color, int count,
float opacity) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
this.offset = offset;
this.color = color;
this.count = count;
this.opacity = opacity;
}
public PaintContext createContext(ColorModel cm,
Rectangle deviceBounds, Rectangle2D userBounds,
AffineTransform xform, RenderingHints hints) {
Point2D t1 = xform.transform(new Point2D.Float(x1, y1), null);
Point2D t2 = xform.transform(new Point2D.Float(x2, y2), null);
return new LinearGradientContext((float) t1.getX(), (float) t1.getY(),
(float) t2.getX(), (float) t2.getY());
}
public int getTransparency() {
return TRANSLUCENT; // why not.. rather than checking each color
}
public class LinearGradientContext implements PaintContext {
int ACCURACY = 2;
float tx1, ty1, tx2, ty2;
public LinearGradientContext(float tx1, float ty1, float tx2, float ty2) {
this.tx1 = tx1;
this.ty1 = ty1;
this.tx2 = tx2;
this.ty2 = ty2;
}
public void dispose() { }
public ColorModel getColorModel() { return ColorModel.getRGBdefault(); }
public Raster getRaster(int x, int y, int w, int h) {
WritableRaster raster =
getColorModel().createCompatibleWritableRaster(w, h);
int[] data = new int[w * h * 4];
// make normalized version of base vector
float nx = tx2 - tx1;
float ny = ty2 - ty1;
float len = (float) Math.sqrt(nx*nx + ny*ny);
if (len != 0) {
nx /= len;
ny /= len;
}
int span = (int) PApplet.dist(tx1, ty1, tx2, ty2) * ACCURACY;
if (span <= 0) {
//System.err.println("span is too small");
// annoying edge case where the gradient isn't legit
int index = 0;
for (int j = 0; j < h; j++) {
for (int i = 0; i < w; i++) {
data[index++] = 0;
data[index++] = 0;
data[index++] = 0;
data[index++] = 255;
}
}
} else {
int[][] interp = new int[span][4];
int prev = 0;
for (int i = 1; i < count; i++) {
int c0 = color[i-1];
int c1 = color[i];
int last = (int) (offset[i] * (span-1));
//System.out.println("last is " + last);
for (int j = prev; j <= last; j++) {
float btwn = PApplet.norm(j, prev, last);
interp[j][0] = (int) PApplet.lerp((c0 >> 16) & 0xff, (c1 >> 16) & 0xff, btwn);
interp[j][1] = (int) PApplet.lerp((c0 >> 8) & 0xff, (c1 >> 8) & 0xff, btwn);
interp[j][2] = (int) PApplet.lerp(c0 & 0xff, c1 & 0xff, btwn);
interp[j][3] = (int) (PApplet.lerp((c0 >> 24) & 0xff, (c1 >> 24) & 0xff, btwn) * opacity);
//System.out.println(j + " " + interp[j][0] + " " + interp[j][1] + " " + interp[j][2]);
}
prev = last;
}
int index = 0;
for (int j = 0; j < h; j++) {
for (int i = 0; i < w; i++) {
//float distance = 0; //PApplet.dist(cx, cy, x + i, y + j);
//int which = PApplet.min((int) (distance * ACCURACY), interp.length-1);
float px = (x + i) - tx1;
float py = (y + j) - ty1;
// distance up the line is the dot product of the normalized
// vector of the gradient start/stop by the point being tested
int which = (int) ((px*nx + py*ny) * ACCURACY);
if (which < 0) which = 0;
if (which > interp.length-1) which = interp.length-1;
//if (which > 138) System.out.println("grabbing " + which);
data[index++] = interp[which][0];
data[index++] = interp[which][1];
data[index++] = interp[which][2];
data[index++] = interp[which][3];
}
}
}
raster.setPixels(0, 0, w, h, data);
return raster;
}
}
}
class RadialGradientPaint implements Paint {
float cx, cy, radius;
float[] offset;
int[] color;
int count;
float opacity;
public RadialGradientPaint(float cx, float cy, float radius,
float[] offset, int[] color, int count,
float opacity) {
this.cx = cx;
this.cy = cy;
this.radius = radius;
this.offset = offset;
this.color = color;
this.count = count;
this.opacity = opacity;
}
public PaintContext createContext(ColorModel cm,
Rectangle deviceBounds, Rectangle2D userBounds,
AffineTransform xform, RenderingHints hints) {
return new RadialGradientContext();
}
public int getTransparency() {
return TRANSLUCENT;
}
public class RadialGradientContext implements PaintContext {
int ACCURACY = 5;
public void dispose() {}
public ColorModel getColorModel() { return ColorModel.getRGBdefault(); }
public Raster getRaster(int x, int y, int w, int h) {
WritableRaster raster =
getColorModel().createCompatibleWritableRaster(w, h);
int span = (int) radius * ACCURACY;
int[][] interp = new int[span][4];
int prev = 0;
for (int i = 1; i < count; i++) {
int c0 = color[i-1];
int c1 = color[i];
int last = (int) (offset[i] * (span - 1));
for (int j = prev; j <= last; j++) {
float btwn = PApplet.norm(j, prev, last);
interp[j][0] = (int) PApplet.lerp((c0 >> 16) & 0xff, (c1 >> 16) & 0xff, btwn);
interp[j][1] = (int) PApplet.lerp((c0 >> 8) & 0xff, (c1 >> 8) & 0xff, btwn);
interp[j][2] = (int) PApplet.lerp(c0 & 0xff, c1 & 0xff, btwn);
interp[j][3] = (int) (PApplet.lerp((c0 >> 24) & 0xff, (c1 >> 24) & 0xff, btwn) * opacity);
}
prev = last;
}
int[] data = new int[w * h * 4];
int index = 0;
for (int j = 0; j < h; j++) {
for (int i = 0; i < w; i++) {
float distance = PApplet.dist(cx, cy, x + i, y + j);
int which = PApplet.min((int) (distance * ACCURACY), interp.length-1);
data[index++] = interp[which][0];
data[index++] = interp[which][1];
data[index++] = interp[which][2];
data[index++] = interp[which][3];
}
}
raster.setPixels(0, 0, w, h, data);
return raster;
}
}
}
protected Paint calcGradientPaint(Gradient gradient) {
if (gradient instanceof LinearGradient) {
LinearGradient grad = (LinearGradient) gradient;
return new LinearGradientPaint(grad.x1, grad.y1, grad.x2, grad.y2,
grad.offset, grad.color, grad.count,
opacity);
} else if (gradient instanceof RadialGradient) {
RadialGradient grad = (RadialGradient) gradient;
return new RadialGradientPaint(grad.cx, grad.cy, grad.r,
grad.offset, grad.color, grad.count,
opacity);
}
return null;
}
// protected Paint calcGradientPaint(Gradient gradient,
// float x1, float y1, float x2, float y2) {
// if (gradient instanceof LinearGradient) {
// LinearGradient grad = (LinearGradient) gradient;
// return new LinearGradientPaint(x1, y1, x2, y2,
// grad.offset, grad.color, grad.count,
// opacity);
// }
// throw new RuntimeException("Not a linear gradient.");
// }
// protected Paint calcGradientPaint(Gradient gradient,
// float cx, float cy, float r) {
// if (gradient instanceof RadialGradient) {
// RadialGradient grad = (RadialGradient) gradient;
// return new RadialGradientPaint(cx, cy, r,
// grad.offset, grad.color, grad.count,
// opacity);
// }
// throw new RuntimeException("Not a radial gradient.");
// }
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
protected void styles(PGraphics g) {
super.styles(g);
if (g instanceof PGraphicsJava2D) {
PGraphicsJava2D p2d = (PGraphicsJava2D) g;
if (strokeGradient != null) {
p2d.strokeGradient = true;
p2d.strokeGradientObject = strokeGradientPaint;
} else {
// need to shut off, in case parent object has a gradient applied
//p2d.strokeGradient = false;
}
if (fillGradient != null) {
p2d.fillGradient = true;
p2d.fillGradientObject = fillGradientPaint;
} else {
// need to shut off, in case parent object has a gradient applied
//p2d.fillGradient = false;
}
}
}
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
//public void drawImpl(PGraphics g) {
// do nothing
//}
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
/**
* Get a particular element based on its SVG ID. When editing SVG by hand,
* this is the id="" tag on any SVG element. When editing from Illustrator,
* these IDs can be edited by expanding the layers palette. The names used
* in the layers palette, both for the layers or the shapes and groups
* beneath them can be used here.
* <PRE>
* // This code grabs "Layer 3" and the shapes beneath it.
* SVG layer3 = svg.getChild("Layer 3");
* </PRE>
*/
public PShape getChild(String name) {
PShape found = super.getChild(name);
if (found == null) {
// Otherwise try with underscores instead of spaces
// (this is how Illustrator handles spaces in the layer names).
found = super.getChild(name.replace(' ', '_'));
}
// Set bounding box based on the parent bounding box
if (found != null) {
// found.x = this.x;
// found.y = this.y;
found.width = this.width;
found.height = this.height;
}
return found;
}
/**
* Prints out the SVG document. Useful for parsing.
*/
public void print() {
PApplet.println(element.toString());
}
}