mazakodron_przerabiator.py

#!/usr/bin/env python
"""
Mazakodron 3000 - Przerabiator 5000

Based on:
synfig_prepare.py
Simplifies SVG files in preparation for sif export.

Copyright (C) 2011 Nikita Kitaev

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

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
"""

from __future__ import print_function
import sys
import os, tempfile

try:
  import inkex
except ImportError:
  sys.path += ['/usr/share/inkscape/extensions']
  sys.path += ['/usr/local/share/inkscape/extensions']
  sys.path += ['C:\\Program Files\\Inkscape\\share\\extensions']
  import inkex

from inkex import NSS, addNS, etree, errormsg
import simplepath, simplestyle, simpletransform

###### Utility Classes ####################################

class MalformedSVGError(Exception):
    """Raised when the SVG document is invalid or contains unsupported features"""
    def __init__(self, value):
        self.value = value
    def __str__(self):
        return """SVG document is invalid or contains unsupported features

Error message: %s

Przerabiator 5000 is designed to handle SVG files that were created using Inkscape. Unsupported features are most likely to occur in SVG files written by other programs.
"""     % repr(self.value)

try:
    from subprocess import Popen, PIPE
    bsubprocess = True
except:
    bsubprocess = False

class InkscapeActionGroup(object):
    """A class for calling Inkscape to perform operations on a document"""
    def __init__(self, svg_document=None):
        self.command = ""
        self.init_args = ""
        self.has_selection = False
        self.has_action = False
        self.svg_document = svg_document
        
        self.tmp = 0

    def set_svg_document(self, svg_document):
        """Set the SVG document that Inkscape will operate on"""
        self.svg_document = svg_document

    def set_init_args(self, cmd):
        """Set the initial arguments to Inkscape subprocess

        Can be used to pass additional arguments to Inkscape, or an initializer
        command (e.g. unlock all objects before proceeding).
        """
        self.init_args = cmd

    def clear(self):
        """Clear all actions"""
        self.command = ""
        self.has_action = False
        self.has_selection = False

    def verb(self, verb):
        """Run an Inkscape verb

        For a list of verbs, run `inkscape --verb-list`
        """
        if self.has_selection:
            self.command += "--verb=%s " % (verb)

            if not self.has_action:
                self.has_action = True

    def select_id(self, object_id):
        """Select object with given id"""
        self.command += "--select='%s' " % (object_id)
        if not self.has_selection:
            self.has_selection = True

    def select_node(self, node):
        """Select the object represented by the SVG node

        Selection will fail if node has no id attribute
        """
        node_id = node.get("id", None)
        if node_id is None:
            raise MalformedSVGError, "Node has no id"
        self.select_id(node_id)

    def select_nodes(self, nodes):
        """Select objects represented by SVG nodes

        Selection will fail if any node has no id attribute
        """
        for node in nodes:
            self.select_node(node)

    def select_xpath(self, xpath, namespaces=NSS):
        """Select objects matching a given XPath expression

        Selection will fail if any matching node has no id attribute
        """
        nodes = self.svg_document.xpath(xpath, namespaces=namespaces)

        self.select_nodes(nodes)
        
    def count_nodes(self, xpath, namespaces=NSS):
        """Counts how many nodes match given XPath expression"""
        
        nodes = self.svg_document.xpath(xpath, namespaces=namespaces)
	return len(nodes)

    def deselect(self):
        """Deselect all objects"""
        if self.has_selection:
            self.verb("EditDeselect")
            self.has_selection = False

    def run_file(self, filename):
        """Run the actions on a specific file"""
        if not self.has_action:
            return

        cmd = self.init_args + " " + self.command + "--verb=FileSave --verb=FileQuit"

        if bsubprocess:
            p = Popen('inkscape "%s" %s' % (filename, cmd), shell=True, stdout=PIPE, stderr=PIPE)
            rc = p.wait()
            f = p.stdout
            err = p.stderr
        else:
            _, f, err = os.popen3( "inkscape %s %s" % ( filename, cmd ) )

        f.close()
        err.close()

    def run_document(self):
        """Run the actions on the svg xml tree"""
        if not self.has_action:
            return self.svg_document

        # First save the document
        svgfile = tempfile.mktemp(".svg")
        self.svg_document.write(svgfile)

        # Run the action on the document
        self.run_file(svgfile)

        # Open the resulting file
        stream = open(svgfile, 'r')
        new_svg_doc = etree.parse(stream)
        stream.close()

        # Clean up.
        try:
            os.remove(svgfile)
        except Exception:
            pass

        # Set the current SVG document
        self.svg_document = new_svg_doc

        # Return the new document
        return new_svg_doc

class MazakodronExportActionGroup(InkscapeActionGroup):
    """An action group with stock commands designed for MZKDRN exporting"""
    def __init__(self, svg_document=None):
        InkscapeActionGroup.__init__(self, svg_document)
        self.set_init_args("--verb=UnlockAllInAllLayers")
        self.objects_to_paths()
        self.ungroup()
        self.unlink_clones()

    def objects_to_paths(self):
        """Convert unsupported objects to paths"""
        # Flow roots contain rectangles inside them, so they need to be
        # converted to paths separately from other shapes
        self.select_xpath("//svg:flowRoot", namespaces=NSS)
        self.verb("ObjectToPath")
        self.deselect()

        non_paths = [
            "svg:rect",
            "svg:circle",
            "svg:ellipse",
            "svg:line",
            "svg:polyline",
            "svg:polygon",
            "svg:text",
            "svg:path" # convert arcs too
            ]

        # Build an xpath command to select these nodes
        xpath_cmd = " | ".join(["//" + np for np in non_paths])

        # Select all of these elements
        # Note: already selected elements are not deselected
        self.select_xpath(xpath_cmd, namespaces=NSS)

        # Convert them to paths
        self.verb("ObjectToPath")
        self.deselect()

    def ungroup(self):
        """Ungroup elements (remove <svg:g> elements)"""
        groups = self.count_nodes("//svg:g", namespaces=NSS)
	for i in range(0, groups):
	  self.select_xpath("//svg:g", namespaces=NSS)
	  self.verb("SelectionUnGroup")
	  self.deselect()
        
        #print(dir(self.select_xpath("//svg:g", namespaces=NSS)), file=sys.stderr);

    def unlink_clones(self):
        """Unlink clones (remove <svg:use> elements)"""
        self.select_xpath("//svg:use", namespaces=NSS)
        self.verb("EditUnlinkClone")
        self.deselect()

###### Utility Functions ##################################

### Path related

def fuse_subpaths(path_node):
    """Fuse subpaths of a path. Should only be used on unstroked paths"""
    path_d = path_node.get("d", None)
    path = simplepath.parsePath(path_d)

    if len(path) == 0:
        return

    i = 0
    initial_point = [ path[i][1][-2], path[i][1][-1] ]
    return_stack = []
    while i < len(path):
        # Remove any terminators: they are redundant
        if path[i][0] == "Z":
            path.remove(["Z", []])
            continue

        # Skip all elements that do not begin a new path
        if i == 0 or path[i][0] != "M":
            i += 1
            continue

        # This element begins a new path - it should be a moveto
        assert(path[i][0] == 'M')

        # Swap it for a lineto
        path[i][0] = 'L'

        # If the old subpath has not been closed yet, close it
        if path[i-1][1][-2] != initial_point[0] or path[i-1][1][-2] != initial_point[1]:
            path.insert(i, ['L', initial_point])
            i += 1

        # Set the initial point of this subpath
        initial_point = [ path[i-1][1][-2], path[i-1][1][-1] ]

        # Append this point to the return stack
        return_stack.append(initial_point)
    #end while

    # Now pop the entire return stack
    while return_stack != []:
        el = ['L', return_stack.pop()]
        path.insert(i, el)
        i += 1


    path_d = simplepath.formatPath(path)
    path_node.set("d", path_d)

def split_fill_and_stroke(path_node):
    """Split a path into two paths, one filled and one stroked

    Returns a the list [fill, stroke], where each is the XML element of the
    fill or stroke, or None.
    """
    style = simplestyle.parseStyle(path_node.get("style", ""))

    # If there is only stroke or only fill, don't split anything
    if "fill" in style.keys() and style["fill"] == "none":
        if "stroke" not in style.keys() or style["stroke"] == "none":
            return [None, None] # Path has neither stroke nor fill
        else:
          style_stroke = {"fill":"none", "stroke":"#000000"}

          for key in style.keys():
            if not key.startswith("fill") and not key.startswith("filter"):
              style_stroke[key] = style[key]
          style_stroke['stroke']='#000000';
          style_stroke['stroke-width']='5px';
          style_stroke['opacity']='1';
          
          #inkex.errormsg(style_stroke)

          path_node.set("style", simplestyle.formatStyle(style_stroke))
          return [None, path_node]
    if "stroke" not in style.keys() or style["stroke"] == "none":
        style_stroke = {"fill":"none", "stroke":"#000000"}

        for key in style.keys():
          if not key.startswith("fill") and not key.startswith("filter"):
            style_stroke[key] = style[key]
        style_stroke['stroke']='#000000';
        style_stroke['stroke-width']='5px';
        style_stroke['opacity']='1';
        #inkex.errormsg(style_stroke)

        path_node.set("style", simplestyle.formatStyle(style_stroke))
        return [None, path_node]

    group = path_node.makeelement(addNS("g", "svg"))
    fill = etree.SubElement(group, addNS("path", "svg"))
    stroke = etree.SubElement(group, addNS("path", "svg"))

    attribs = path_node.attrib

    if "d" in attribs.keys():
        d = attribs["d"]
        del attribs["d"]
    else:
        raise AssertionError, "Cannot split stroke and fill of non-path element"

    if addNS("nodetypes", "sodipodi") in attribs.keys():
        nodetypes = attribs[addNS("nodetypes", "sodipodi")]
        del attribs[addNS("nodetypes", "sodipodi")]
    else:
        nodetypes = None

    if "id" in attribs.keys():
        path_id = attribs["id"]
        del attribs["id"]
    else:
        path_id = str(id(path_node))

    if "style" in attribs.keys():
        del attribs["style"]

    if "transform" in attribs.keys():
        transform = attribs["transform"]
        del attribs["transform"]
    else:
        transform = None

    # Pass along all remaining attributes to the group
    for attrib_name in attribs.keys():
        group.set(attrib_name, attribs[attrib_name])

    group.set("id", path_id)

    # Next split apart the style attribute
    style_group = {}
    style_fill = {"stroke":"none", "fill":"#000000"}
    style_stroke = {"fill":"none", "stroke":"#000000"}

    for key in style.keys():
        if key.startswith("fill"):
            style_fill[key] = style[key]
        elif key.startswith("stroke"):
            style_stroke[key] = style[key]
        elif key.startswith("marker"):
            style_stroke[key] = style[key]
            #wtf
        elif key.startswith("filter"):
            pass
            #style_group[key] = style[key]
        else:
            style_fill[key] = style[key]
            style_stroke[key] = style[key]

    style_stroke['stroke'] = '#000000';
    style_stroke['stroke-width']='5px';
    style_stroke['opacity']='1';
    
    if len(style_group) != 0:
        group.set("style", simplestyle.formatStyle(style_group))

    fill.set("style", simplestyle.formatStyle(style_fill))
    stroke.set("style", simplestyle.formatStyle(style_stroke))

    # Finalize the two paths
    fill.set("d", d)
    stroke.set("d", d)
    if nodetypes is not None:
        fill.set(addNS("nodetypes", "sodipodi"), nodetypes)
        stroke.set(addNS("nodetypes", "sodipodi"), nodetypes)
    fill.set("id", path_id+"-fill")
    stroke.set("id", path_id+"-stroke")
    if transform is not None:
        fill.set("transform", transform)
        stroke.set("transform", transform)


    # Replace the original node with the group
    path_node.getparent().replace(path_node, group)

    return [fill, stroke]

### Object related

def propagate_attribs(node, parent_style={}, parent_transform=[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]):
    """Propagate style and transform to remove inheritance"""

    # Don't enter non-graphical portions of the document
    if (node.tag == addNS("namedview", "sodipodi")
        or node.tag == addNS("defs", "svg")
        or node.tag == addNS("metadata", "svg")
        or node.tag == addNS("foreignObject", "svg")):
        return


    # Compose the transformations
    if node.tag == addNS("svg", "svg") and node.get("viewBox"):
        vx, vy, vw, vh = [get_dimension(x) for x in node.get("viewBox").split()]
        dw = get_dimension(node.get("width", vw))
        dh = get_dimension(node.get("height", vh))
        t = "translate(%f, %f) scale(%f, %f)" % (-vx, -vy, dw/vw, dh/vh)
        this_transform = simpletransform.parseTransform(t, parent_transform)
        this_transform = simpletransform.parseTransform(node.get("transform"), this_transform)
        del node.attrib["viewBox"]
    else:
        this_transform = simpletransform.parseTransform(node.get("transform"), parent_transform)

    # Compose the style attribs
    this_style = simplestyle.parseStyle(node.get("style", ""))
    remaining_style = {} # Style attributes that are not propagated

    non_propagated = ["filter"] # Filters should remain on the topmost ancestor
    for key in non_propagated:
        if key in this_style.keys():
            remaining_style[key] = this_style[key]
            del this_style[key]

    # Create a copy of the parent style, and merge this style into it
    parent_style_copy = parent_style.copy()
    parent_style_copy.update(this_style)
    this_style = parent_style_copy

    # Merge in any attributes outside of the style
    style_attribs = ["fill", "stroke"]
    for attrib in style_attribs:
        if node.get(attrib):
            this_style[attrib] = node.get(attrib)
            del node.attrib[attrib]

    if (node.tag == addNS("svg", "svg")
        or node.tag == addNS("g", "svg")
        or node.tag == addNS("a", "svg")
        or node.tag == addNS("switch", "svg")):
      # Leave only non-propagating style attributes
	if len(remaining_style) == 0:
	    if "style" in node.keys():
		del node.attrib["style"]
	else:
	    node.set("style", simplestyle.formatStyle(remaining_style))

	# Remove the transform attribute
	if "transform" in node.keys():
	    del node.attrib["transform"]

	# Continue propagating on subelements
	for c in node.iterchildren():
	    propagate_attribs(c, this_style, this_transform)
    else:
        # This element is not a container

        # Merge remaining_style into this_style
        this_style.update(remaining_style)

        # Set the element's style and transform attribs
        node.set("style", simplestyle.formatStyle(this_style))
        node.set("transform", simpletransform.formatTransform(this_transform))

    if node.get('d')!=None:
      simpletransform.fuseTransform(node)

### Style related

def get_dimension(s="1024"):
    """Convert an SVG length string from arbitrary units to pixels"""
    if s == "":
        return 0
    try:
        last = int(s[-1])
    except:
        last = None

    if type(last) == int:
        return float(s)
    elif s[-1] == "%":
        return 1024
    elif s[-2:] == "px":
        return float(s[:-2])
    elif s[-2:] == "pt":
        return float(s[:-2])*1.25
    elif s[-2:] == "em":
        return float(s[:-2])*16
    elif s[-2:] == "mm":
        return float(s[:-2])*3.54
    elif s[-2:] == "pc":
        return float(s[:-2])*15
    elif s[-2:] == "cm":
        return float(s[:-2])*35.43
    elif s[-2:] == "in":
        return float(s[:-2])*90
    else:
        return 1024

###### Main Class #########################################
class MazakodronPrep(inkex.Effect):
    def effect(self):
        """Transform document in preparation for exporting it into the MZKDRN format"""

        a = MazakodronExportActionGroup(self.document)
        self.document = a.run_document()

        # Remove inheritance of attributes
        propagate_attribs(self.document.getroot())

        # Fuse multiple subpaths in fills
        for node in self.document.xpath('//svg:path', namespaces=NSS):
            #inkex.errormsg(dir(node));
            #if node.get("d", "").lower().count("m") > 1:
            # There are multiple subpaths
            (fill,stroke) = split_fill_and_stroke(node)
            #    if fill is not None:
            #        fuse_subpaths(fill)
            #inkex.errormsg(type(node));
            if fill is not None:
              fill.getparent().remove(fill);
            if stroke is not None:
              stroke.set('color','#00000000');

if __name__ == '__main__':
    try:
        e = MazakodronPrep()
        e.affect()
    except MalformedSVGError, e:
        errormsg(e)


# vim: expandtab shiftwidth=4 tabstop=8 softtabstop=4 fileencoding=utf-8 textwidth=99