• Home
• org.praxislive.libp5x
• processing-core
• 4.430.1
• source code
• PShapeSVG.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

processing.core.PShapeSVG Maven / Gradle / Ivy

/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */

/*
  Part of the Processing project - http://processing.org

  Copyright (c) 2012-22 The Processing Foundation
  Copyright (c) 2006-12 Ben Fry and Casey Reas
  Copyright (c) 2004-06 Michael Chang

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License version 2.1 as published by the Free Software Foundation.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General
  Public License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  Boston, MA  02111-1307  USA
*/

package processing.core;

import static java.awt.Font.BOLD;
import static java.awt.Font.ITALIC;
import static java.awt.Font.PLAIN;
import processing.data.*;

// TODO replace these with PMatrix2D
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;

import java.util.Map;
import java.util.HashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * This class is not part of the Processing API and should not be used
 * directly. Instead, use loadShape() and methods like it, which will make
 * use of this class. Using this class directly will cause your code to break
 * when combined with future versions of Processing.
 * 

 * 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.
 * View the SVG specification here.
 * 

 * We have no intention of turning this into a full-featured SVG library.
 * The goal of this project is a basic shape importer that originally was small
 * enough to be included with applets, meaning that its download size should be
 * in the neighborhood of 25-30 Kb. Though we're far less limited nowadays on
 * size constraints, we remain extremely limited in terms of time, and do not
 * have volunteers who are available to maintain a larger SVG library.
 * 

 * For more sophisticated import/export, consider the
 * Batik
 * library from the Apache Software Foundation.
 * 

 * Batik is used in the SVG Export library in Processing 3, however using it
 * for full SVG import is still a considerable amount of work. Wiring it to
 * Java2D wouldn't be too bad, but using it with OpenGL, JavaFX, and features
 * like begin/endRecord() and begin/endRaw() would be considerable effort.
 * 

 * Future improvements to this library may focus on this properly supporting
 * a specific subset of SVG, for instance the simpler SVG profiles known as
 * SVG Tiny or Basic,
 * although we still would not support the interactivity options.
 *
 * 
 
 

 *
 * A minimal example program using SVG:
 * (assuming a working moo.svg is in your data folder)
 *
 * 
 * PShape moo;
 *
 * void setup() {
 *   size(400, 400);
 *   moo = loadShape("moo.svg");
 * }
 * void draw() {
 *   background(255);
 *   shape(moo, mouseX, mouseY);
 * }
 * 
 */
public class PShapeSVG extends PShape {
  XML element;

  /// Values between 0 and 1.
  protected float opacity;
  float strokeOpacity;
  float fillOpacity;

  /** Width of containing SVG (used for percentages). */
  protected float svgWidth;

  /** Height of containing SVG (used for percentages). */
  protected float svgHeight;

  /** √((w² + h²)/2) of containing SVG (used for percentages). */
  protected float svgSizeXY;

  protected Gradient strokeGradient;
  String strokeName;  // id of another object, gradients only?

  protected Gradient fillGradient;
  String fillName;  // id of another object


  /**
   * Initializes a new SVG object from the given XML object.
   */
  public PShapeSVG(XML svg) {
    this(null, svg, true);

    if (!svg.getName().equals("svg")) {
      if (svg.getName().equalsIgnoreCase("html")) {
        // Common case is that files aren't downloaded properly
        throw new RuntimeException("This appears to be a web page, not an SVG file.");
      } else {
        throw new RuntimeException("The root node is not 

   * 
"1pt" equals "1.25px" (and therefore 1.25 user units)
   * 
"1pc" equals "15px" (and therefore 15 user units)
   * 
"1mm" would be "3.543307px" (3.543307 user units)
   * 
"1cm" equals "35.43307px" (and therefore 35.43307 user units)
   * 
"1in" equals "90px" (and therefore 90 user units)
   * 
   * @param relativeTo (float) Used for %. When relative to viewbox, should
   *    be svgWidth for horizontal dimentions, svgHeight for vertical, and
   *    svgXYSize for anything else.
   */
  static protected float parseUnitSize(String text, float relativeTo) {
    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 if (text.endsWith("%")) {
      return relativeTo * parseFloatOrPercent(text);
    } else {
      return PApplet.parseFloat(text);
    }
  }


  static protected float parseFloatOrPercent(String text) {
    text = text.trim();
    if (text.endsWith("%")) {
      return Float.parseFloat(text.substring(0, text.length() - 1)) / 100.0f;
    } else {
      return Float.parseFloat(text);
    }
  }


  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


  static public class Gradient extends PShapeSVG {
    AffineTransform transform;

    public float[] offset;
    public int[] color;
    public int count;

    public Gradient(PShapeSVG parent, XML properties) {
      super(parent, properties, true);

      XML[] elements = properties.getChildren();
      offset = new float[elements.length];
      color = new int[elements.length];

      // 
      for (int i = 0; i < elements.length; i++) {
        XML elem = elements[i];
        String name = elem.getName();
        if (name.equals("stop")) {
          String offsetAttr = elem.getString("offset");
          offset[count] = parseFloatOrPercent(offsetAttr);

          String style = elem.getString("style");
          //Map styles = parseStyleAttributes(style);
          StringDict styles = parseStyleAttributes(style);

          String colorStr = styles.get("stop-color");
          if (colorStr == null) {
            colorStr = elem.getString("stop-color");
            if (colorStr == null) colorStr = "#000000";
          }
          String opacityStr = styles.get("stop-opacity");
          if (opacityStr == null) {
            opacityStr = elem.getString("stop-opacity");
            if (opacityStr == null) opacityStr = "1";
          }
          int tupacity = PApplet.constrain(
                          (int)(PApplet.parseFloat(opacityStr) * 255), 0, 255);
          color[count] = (tupacity << 24) | parseSimpleColor(colorStr);
          count++;
        }
      }
      offset = PApplet.subset(offset, 0, count);
      color = PApplet.subset(color, 0, count);
    }
  }


  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


  static public class LinearGradient extends Gradient {
    public float x1, y1, x2, y2;

    public LinearGradient(PShapeSVG parent, XML properties) {
      super(parent, properties);

      this.x1 = getFloatWithUnit(properties, "x1", svgWidth);
      this.y1 = getFloatWithUnit(properties, "y1", svgHeight);
      this.x2 = getFloatWithUnit(properties, "x2", svgWidth);
      this.y2 = getFloatWithUnit(properties, "y2", svgHeight);

      String transformStr =
        properties.getString("gradientTransform");

      if (transformStr != null) {
        float[] t = parseTransform(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();
      }
    }
  }


  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


  static public class RadialGradient extends Gradient {
    public float cx, cy, r;

    public RadialGradient(PShapeSVG parent, XML properties) {
      super(parent, properties);

      this.cx = getFloatWithUnit(properties, "cx", svgWidth);
      this.cy = getFloatWithUnit(properties, "cy", svgHeight);
      this.r  = getFloatWithUnit(properties, "r", svgSizeXY);

      String transformStr =
        properties.getString("gradientTransform");

      if (transformStr != null) {
        float[] t = parseTransform(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());
      }
    }
  }


  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


//  static private float TEXT_QUALITY = 1;

  static private PFont parseFont(XML properties) {
    String fontFamily = null;
    float size = 10;
    int weight = PLAIN; // 0
    int italic = 0;

    if (properties.hasAttribute("style")) {
      String styleText = properties.getString("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("font-style")) {
          // PApplet.println("font-style: " + tokens[1]);
          if (tokens[1].contains("italic")) {
            italic = ITALIC;
          }
        } else if (tokens[0].equals("font-variant")) {
          // PApplet.println("font-variant: " + tokens[1]);
          // setFillOpacity(tokens[1]);

        } else if (tokens[0].equals("font-weight")) {
          // PApplet.println("font-weight: " + tokens[1]);

          if (tokens[1].contains("bold")) {
            weight = BOLD;
            // PApplet.println("Bold weight ! ");
          }


        } else if (tokens[0].equals("font-stretch")) {
          // not supported.

        } else if (tokens[0].equals("font-size")) {
          // PApplet.println("font-size: " + tokens[1]);
          size = Float.parseFloat(tokens[1].split("px")[0]);
          // PApplet.println("font-size-parsed: " + size);
        } else if (tokens[0].equals("line-height")) {
                // not supported

        } else if (tokens[0].equals("font-family")) {
          // PApplet.println("Font-family: " + tokens[1]);
          fontFamily = tokens[1];

        } else if (tokens[0].equals("text-align")) {
          // not supported

        } else if (tokens[0].equals("letter-spacing")) {
                // not supported

        } else if (tokens[0].equals("word-spacing")) {
                // not supported

        } else if (tokens[0].equals("writing-mode")) {
          // not supported

        } else if (tokens[0].equals("text-anchor")) {
          // not supported

        } else {
          // Other attributes are not yet implemented
        }
      }
    }
    if (fontFamily == null) {
      return null;
    }
//    size = size * TEXT_QUALITY;

    return createFont(fontFamily, weight | italic, size, true);
  }


  static protected PFont createFont(String name, int weight,
                                    float size, boolean smooth) {
    //System.out.println("Try to create a font of " + name + " family, " + weight);
    java.awt.Font baseFont = new java.awt.Font(name, weight, (int) size);

    //System.out.println("Resulting family : " + baseFont.getFamily() + " " + baseFont.getStyle());
    return new PFont(baseFont.deriveFont(size), smooth, null);
  }


  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


  static public class Text extends PShapeSVG {
    protected PFont font;

    public Text(PShapeSVG parent, XML properties) {
      super(parent, properties, true);

            // get location
      float x = Float.parseFloat(properties.getString("x"));
      float y = Float.parseFloat(properties.getString("y"));

      if (matrix == null) {
        matrix = new PMatrix2D();
      }
      matrix.translate(x, y);

      family = GROUP;

      font = parseFont(properties);
    }
  }


  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


  static public class LineOfText extends PShapeSVG {
    String textToDisplay;
    PFont font;

    public LineOfText(PShapeSVG parent, XML properties) {
      // TODO: child should ideally be parsed too for inline content.
      super(parent, properties, false);

      //get location
      float x = Float.parseFloat(properties.getString("x"));
      float y = Float.parseFloat(properties.getString("y"));

      float parentX = Float.parseFloat(parent.element.getString("x"));
      float parentY = Float.parseFloat(parent.element.getString("y"));

      if (matrix == null) matrix = new PMatrix2D();
      matrix.translate(x - parentX, (y - parentY) / 2f);

      // get the first properties
      parseColors(properties);
      font = parseFont(properties);

      // cleaned up syntax but removing b/c unused [fry 190118]
      //boolean isLine = properties.getString("role").equals("line");

      if (this.childCount > 0) {
        // no inline content yet.
      }

      String text = properties.getContent();
      textToDisplay = text;
    }

    @Override
    public void drawImpl(PGraphics g) {
      if (font == null) {
        font = ((Text) parent).font;
        if (font == null) {
          return;
        }
      }

      pre(g);
//      g.textFont(font, font.size / TEXT_QUALITY);
      g.textFont(font, font.size);
      g.text(textToDisplay, 0, 0);
      post(g);
    }
  }


  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


  static public class Font extends PShapeSVG {
    public FontFace face;

    public Map namedGlyphs;
    public Map unicodeGlyphs;

    public int glyphCount;
    public FontGlyph[] glyphs;
    public FontGlyph missingGlyph;

    int horizAdvX;


    public Font(PShapeSVG parent, XML properties) {
      super(parent, properties, false);
//      handle(parent, properties);

      XML[] elements = properties.getChildren();

      horizAdvX = properties.getInt("horiz-adv-x", 0);

      namedGlyphs = new HashMap<>();
      unicodeGlyphs = new HashMap<>();
      glyphCount = 0;
      glyphs = new FontGlyph[elements.length];

      for (int i = 0; i < elements.length; i++) {
        String name = elements[i].getName();
        XML elem = elements[i];
        if (name == null) {
          // skip it
        } else if (name.equals("glyph")) {
          FontGlyph fg = new FontGlyph(this, elem, this);
          if (fg.isLegit()) {
            if (fg.name != null) {
              namedGlyphs.put(fg.name, fg);
            }
            if (fg.unicode != 0) {
              unicodeGlyphs.put(Character.valueOf(fg.unicode), fg);
            }
          }
          glyphs[glyphCount++] = fg;

        } else if (name.equals("missing-glyph")) {
//          System.out.println("got missing glyph inside ");
          missingGlyph = new FontGlyph(this, elem, this);
        } else if (name.equals("font-face")) {
          face = new FontFace(this, elem);
        } else {
          System.err.println("Ignoring " + name + " inside ");
        }
      }
    }


    protected void drawShape() {
      // does nothing for fonts
    }


    public void drawString(PGraphics g, String str, float x, float y, float size) {
      // 1) scale by the 1.0/unitsPerEm
      // 2) scale up by a font size
      g.pushMatrix();
      float s =  size / face.unitsPerEm;
      //System.out.println("scale is " + s);
      // swap y coord at the same time, since fonts have y=0 at baseline
      g.translate(x, y);
      g.scale(s, -s);
      char[] c = str.toCharArray();
      for (int i = 0; i < c.length; i++) {
        // call draw on each char (pulling it w/ the unicode table)
        FontGlyph fg = unicodeGlyphs.get(Character.valueOf(c[i]));
        if (fg != null) {
          fg.draw(g);
          // add horizAdvX/unitsPerEm to the x coordinate along the way
          g.translate(fg.horizAdvX, 0);
        } else {
          System.err.println("'" + c[i] + "' not available.");
        }
      }
      g.popMatrix();
    }


    public void drawChar(PGraphics g, char c, float x, float y, float size) {
      g.pushMatrix();
      float s =  size / face.unitsPerEm;
      g.translate(x, y);
      g.scale(s, -s);
      FontGlyph fg = unicodeGlyphs.get(Character.valueOf(c));
      if (fg != null) g.shape(fg);
      g.popMatrix();
    }


    public float textWidth(String str, float size) {
      float w = 0;
      char[] c = str.toCharArray();
      for (int i = 0; i < c.length; i++) {
        // call draw on each char (pulling it w/ the unicode table)
        FontGlyph fg = unicodeGlyphs.get(Character.valueOf(c[i]));
        if (fg != null) {
          w += (float) fg.horizAdvX / face.unitsPerEm;
        }
      }
      return w * size;
    }
  }


  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


  static class FontFace extends PShapeSVG {
    int horizOriginX;  // dflt 0
    int horizOriginY;  // dflt 0
//    int horizAdvX;     // no dflt?
    int vertOriginX;   // dflt horizAdvX/2
    int vertOriginY;   // dflt ascent
    int vertAdvY;      // dflt 1em (unitsPerEm value)

    String fontFamily;
    int fontWeight;    // can also be normal or bold (also comma separated)
    String fontStretch;
    int unitsPerEm;    // dflt 1000
    int[] panose1;     // dflt "0 0 0 0 0 0 0 0 0 0"
    int ascent;
    int descent;
    int[] bbox;        // spec says comma separated, tho not w/ forge
    int underlineThickness;
    int underlinePosition;
    //String unicodeRange; // gonna ignore for now


    public FontFace(PShapeSVG parent, XML properties) {
      super(parent, properties, true);

      unitsPerEm = properties.getInt("units-per-em", 1000);
    }


    protected void drawShape() {
      // nothing to draw in the font face attribute
    }
  }


  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


  static public class FontGlyph extends PShapeSVG {  // extends Path
    public String name;
    char unicode;
    int horizAdvX;

    public FontGlyph(PShapeSVG parent, XML properties, Font font) {
      super(parent, properties, true);
      super.parsePath();  // ??

      name = properties.getString("glyph-name");
      String u = properties.getString("unicode");
      unicode = 0;
      if (u != null) {
        if (u.length() == 1) {
          unicode = u.charAt(0);
          //System.out.println("unicode for " + name + " is " + u);
        } else {
          System.err.println("unicode for " + name +
                             " is more than one char: " + u);
        }
      }
      if (properties.hasAttribute("horiz-adv-x")) {
        horizAdvX = properties.getInt("horiz-adv-x");
      } else {
        horizAdvX = font.horizAdvX;
      }
    }


    protected boolean isLegit() {  // TODO need a better way to handle this...
      return vertexCount != 0;
    }
  }


  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


  /**
   * 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.
   * 
   * // This code grabs "Layer 3" and the shapes beneath it.
   * PShape layer3 = svg.getChild("Layer 3");
   * 
   */
  @Override
  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());
  }
}