mightyscape-1.1-deprecated/extensions/fablabchemnitz/fablabchemnitz_eggbot_twist.py

#!/usr/bin/env python3

# twist.py -- Primarily a simple example of writing an Inkscape extension
#             which manipulates objects in a drawing.
#
# For a polygon with vertices V[0], V[1], V[2], ..., V[n-1] iteratively
# move each vertex V[i] by a constant factor 0 < s < 1.0 along the edge
# between V[i] and V[i+1 modulo n] for 0 <= i <= n-1.
#
# This extension operates on every selected closed path, or, if no paths
# are selected, then every closed path in the document.  Since the "twisting"
# effect only concerns itself with individual paths, no effort is made to
# worry about the transforms applied to the paths.  That is, it is not
# necessary to worry about tracking SVG transforms as all the work can be
# done using the untransformed coordinates of each path.

# Written by Daniel C. Newman ( dan dot newman at mtbaldy dot us )
# 19 October 2010

# 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; either version 2 of the License, or
# (at your option) any later version.
#
# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import inkex
from inkex import Transform
from inkex import bezier
from inkex.paths import Path, CubicSuperPath
from lxml import etree

def subdivideCubicPath(sp, flat, i=1):
    """
    [ Lifted from eggbot.py with impunity ]

    Break up a bezier curve into smaller curves, each of which
    is approximately a straight line within a given tolerance
    (the "smoothness" defined by [flat]).

    This is a modified version of cspsubdiv.cspsubdiv(): rewritten
    because recursion-depth errors on complicated line segments
    could occur with cspsubdiv.cspsubdiv().
    """

    while True:
        while True:
            if i >= len(sp):
                return

            p0 = sp[i - 1][1]
            p1 = sp[i - 1][2]
            p2 = sp[i][0]
            p3 = sp[i][1]

            b = (p0, p1, p2, p3)

            if bezier.maxdist(b) > flat:
                break

            i += 1

        one, two = bezier.beziersplitatt(b, 0.5)
        sp[i - 1][2] = one[1]
        sp[i][0] = two[2]
        p = [one[2], one[3], two[1]]
        sp[i:1] = [p]


def distanceSquared(p1, p2):
    """
    Pythagorean distance formula WITHOUT the square root.  Since
    we just want to know if the distance is less than some fixed
    fudge factor, we can just square the fudge factor once and run
    with it rather than compute square roots over and over.
    """

    dx = p2[0] - p1[0]
    dy = p2[1] - p1[1]

    return dx * dx + dy * dy


class Twist(inkex.Effect):

    def __init__(self):

        inkex.Effect.__init__(self)
        self.arg_parser.add_argument("--nSteps", type=int,  default=8, help="Number of iterations to take")
        self.arg_parser.add_argument("--fRatio", type=float, default=0.2, help="Some ratio")

        """
        Store each path in an associative array (dictionary) indexed
        by the lxml.etree pointer for the SVG document element
        containing the path.  Looking up the path in the dictionary
        yields a list of lists.  Each of these lists is a subpath
        # of the path.  E.g., for the SVG path

            <path d="M 10,10 l 0,5 l 5,0 l 0,-5 Z M 30,30 L 30,60"/>

         we'd have two subpaths which will be reduced to absolute
         coordinates.

            subpath_1 = [ [10, 10], [10, 15], [15, 15], [15, 10], [10,10] ]
            subpath_2 = [ [30, 30], [30, 60] ]
            self.paths[<node pointer>] = [ subpath_1, subpath_2 ]

        All of the paths and their subpaths could be drawn as follows:

            for path in self.paths:
                for subpath in self.paths[path]:
                    first = True
                    for vertex in subpath:
                        if first:
                            moveto( vertex[0], vertex[1] )
                            first = False
                        else:
                            lineto( vertex[0], vertex[1] )

        NOTE: drawing all the paths like the above would not in general
        give the correct rendering of the document UNLESS path transforms
        were also tracked and applied.
        """

        self.paths = {}
        self.paths_clone_transform = {}

    def addPathVertices(self, path, node=None, transform=None, clone_transform=None):

        """
        Decompose the path data from an SVG element into individual
        subpaths, each subpath consisting of absolute move to and line
        to coordinates.  Place these coordinates into a list of polygon
        vertices.
        """

        if (not path) or (len(path) == 0):
            # Nothing to do
            return

        sp = Path(path)
        if (not sp) or (len(sp) == 0):
            # Path must have been devoid of any real content
            return

        # Get a cubic super path
        p = CubicSuperPath(sp)
        if (not p) or (len(p) == 0):
            # Probably never happens, but...
            return

        # Now traverse the cubic super path
        subpath_list = []
        subpath_vertices = []
        for sp in p:
            if len(subpath_vertices):
                # There's a prior subpath: see if it is closed and should be saved
                if distanceSquared(subpath_vertices[0], subpath_vertices[-1]) < 1:
                    # Keep the prior subpath: it appears to be a closed path
                    subpath_list.append(subpath_vertices)
            subpath_vertices = []
            subdivideCubicPath(sp, 0.2)
            for csp in sp:
                # Add this vertex to the list of vertices
                subpath_vertices.append(csp[1])

        # Handle final subpath
        if len(subpath_vertices):
            if distanceSquared(subpath_vertices[0], subpath_vertices[-1]) < 1:
                # Path appears to be closed so let's keep it
                subpath_list.append(subpath_vertices)

        # Empty path?
        if not subpath_list:
            return

        # Store the list of subpaths in a dictionary keyed off of the path's node pointer
        self.paths[node] = subpath_list
        self.paths_clone_transform[node] = clone_transform

    def recursivelyTraverseSvg(self, a_node_list, mat_current=None, parent_visibility='visible', clone_transform=None):

        """
        [ This too is largely lifted from eggbot.py ]

        Recursively walk the SVG document, building polygon vertex lists
        for each graphical element we support.

        Rendered SVG elements:
            <circle>, <ellipse>, <line>, <path>, <polygon>, <polyline>, <rect>

        Supported SVG elements:
            <group>, <use>

        Ignored SVG elements:
            <defs>, <eggbot>, <metadata>, <namedview>, <pattern>,
            processing directives

        All other SVG elements trigger an error (including <text>)
        """

        if mat_current is None:
            mat_current = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]

        for node in a_node_list:

            # Ignore invisible nodes
            v = node.get('visibility', parent_visibility)
            if v == 'inherit':
                v = parent_visibility
            if v == 'hidden' or v == 'collapse':
                pass

            # First apply the current matrix transform to this node's transform
            mat_new = Transform(mat_current) * Transform(node.get("transform"))

            if node.tag in [inkex.addNS('g', 'svg'), 'g']:
                self.recursivelyTraverseSvg(node, mat_new, parent_visibility=v)

            elif node.tag in [inkex.addNS('use', 'svg'), 'use']:

                # A <use> element refers to another SVG element via an xlink:href="#blah"
                # attribute.  We will handle the element by doing an XPath search through
                # the document, looking for the element with the matching id="blah"
                # attribute.  We then recursively process that element after applying
                # any necessary (x,y) translation.
                #
                # Notes:
                #  1. We ignore the height and width attributes as they do not apply to
                #     path-like elements, and
                #  2. Even if the use element has visibility="hidden", SVG still calls
                #     for processing the referenced element.  The referenced element is
                #     hidden only if its visibility is "inherit" or "hidden".

                refid = node.get(inkex.addNS('href', 'xlink'))
                if not refid:
                    pass

                # [1:] to ignore leading '#' in reference
                path = '//*[@id="{}"]'.format(refid[1:])
                refnode = node.xpath(path)
                if refnode:
                    x = float(node.get('x', '0'))
                    y = float(node.get('y', '0'))
                    # Note: the transform has already been applied
                    if (x != 0) or (y != 0):
                        mat_new2 = composeTransform(mat_new, parseTransform('translate({:f},{:f})'.format(x, y)))
                    else:
                        mat_new2 = mat_new
                    v = node.get('visibility', v)
                    self.recursivelyTraverseSvg(refnode, mat_new2,
                                                parent_visibility=v, clone_transform=node.get('transform'))

            elif node.tag == inkex.addNS('path', 'svg'):
                path_data = node.get('d')
                if path_data:
                    self.addPathVertices(path_data, node, mat_new, clone_transform)

            elif node.tag in [inkex.addNS('rect', 'svg'), 'rect']:

                # Manually transform
                #
                #    <rect x="X" y="Y" width="W" height="H"/>
                #
                # into
                #
                #    <path d="MX,Y lW,0 l0,H l-W,0 z"/>
                #
                # I.e., explicitly draw three sides of the rectangle and the
                # fourth side implicitly

                # Create a path with the outline of the rectangle
                x = float(node.get('x'))
                y = float(node.get('y'))
                if (not x) or (not y):
                    pass
                w = float(node.get('width', '0'))
                h = float(node.get('height', '0'))
                a = []
                a.append(['M', [x, y]])
                a.append(['l', [w, 0]])
                a.append(['l', [0, h]])
                a.append(['l', [-w, 0]])
                a.append(['Z', []])
                self.addPathVertices(Path(a), node, mat_new, clone_transform)

            elif node.tag in [inkex.addNS('line', 'svg'), 'line']:

                # Convert
                #
                #   <line x1="X1" y1="Y1" x2="X2" y2="Y2/>
                #
                # to
                #
                #   <path d="MX1,Y1 LX2,Y2"/>

                x1 = float(node.get('x1'))
                y1 = float(node.get('y1'))
                x2 = float(node.get('x2'))
                y2 = float(node.get('y2'))
                if (not x1) or (not y1) or (not x2) or (not y2):
                    pass
                a = []
                a.append(['M ', [x1, y1]])
                a.append([' L ', [x2, y2]])
                self.addPathVertices(Path(a), node, mat_new, clone_transform)

            elif node.tag in [inkex.addNS('polyline', 'svg'), 'polyline']:

                # Convert
                #
                #  <polyline points="x1,y1 x2,y2 x3,y3 [...]"/>
                #
                # to
                #
                #   <path d="Mx1,y1 Lx2,y2 Lx3,y3 [...]"/>
                #
                # Note: we ignore polylines with no points

                pl = node.get('points', '').strip()
                if pl == '':
                    pass

                pa = pl.split()
                d = "".join(["M " + pa[i] if i == 0 else " L " + pa[i] for i in range(0, len(pa))])
                self.addPathVertices(d, node, mat_new, clone_transform)

            elif node.tag in [inkex.addNS('polygon', 'svg'), 'polygon']:

                # Convert
                #
                #  <polygon points="x1,y1 x2,y2 x3,y3 [...]"/>
                #
                # to
                #
                #   <path d="Mx1,y1 Lx2,y2 Lx3,y3 [...] Z"/>
                #
                # Note: we ignore polygons with no points

                pl = node.get('points', '').strip()
                if pl == '':
                    pass

                pa = pl.split()
                d = "".join(["M " + pa[i] if i == 0 else " L " + pa[i] for i in range(0, len(pa))])
                d += " Z"
                self.addPathVertices(d, node, mat_new, clone_transform)

            elif node.tag in [inkex.addNS('ellipse', 'svg'), 'ellipse',
                              inkex.addNS('circle', 'svg'), 'circle']:

                # Convert circles and ellipses to a path with two 180 degree arcs.
                # In general (an ellipse), we convert
                #
                #   <ellipse rx="RX" ry="RY" cx="X" cy="Y"/>
                #
                # to
                #
                #   <path d="MX1,CY A RX,RY 0 1 0 X2,CY A RX,RY 0 1 0 X1,CY"/>
                #
                # where
                #
                #   X1 = CX - RX
                #   X2 = CX + RX
                #
                # Note: ellipses or circles with a radius attribute of value 0 are ignored

                if node.tag in [inkex.addNS('ellipse', 'svg'),  'ellipse']:
                    rx = float(node.get('rx', '0'))
                    ry = float(node.get('ry', '0'))
                else:
                    rx = float(node.get('r', '0'))
                    ry = rx
                if rx == 0 or ry == 0:
                    pass

                cx = float(node.get('cx', '0'))
                cy = float(node.get('cy', '0'))
                x1 = cx - rx
                x2 = cx + rx
                d = 'M {x1:f},{cy:f} ' \
                    'A {rx:f},{ry:f} ' \
                    '0 1 0 {x2:f},{cy:f} ' \
                    'A {rx:f},{ry:f} ' \
                    '0 1 0 {x1:f},{cy:f}'.format(x1=x1,
                                                 x2=x2,
                                                 rx=rx,
                                                 ry=ry,
                                                 cy=cy)

                self.addPathVertices(d, node, mat_new, clone_transform)

            elif node.tag in [inkex.addNS('pattern', 'svg'), 'pattern']:
                pass

            elif node.tag in [inkex.addNS('metadata', 'svg'), 'metadata']:
                pass

            elif node.tag in [inkex.addNS('defs', 'svg'), 'defs']:
                pass

            elif node.tag in [inkex.addNS('namedview', 'sodipodi'), 'namedview']:
                pass

            elif node.tag in [inkex.addNS('eggbot', 'svg'), 'eggbot']:
                pass

            elif node.tag in [inkex.addNS('text', 'svg'), 'text']:
                inkex.errormsg('Warning: unable to draw text, please convert it to a path first.')
                pass

            elif not isinstance(node.tag, basestring):
                pass

            else:
                inkex.errormsg('Warning: unable to draw object <{}>, please convert it to a path first.'.format(node.tag))
                pass

    def joinWithNode(self, node, path, make_group=False, clone_transform=None):

        """
        Generate a SVG <path> element containing the path data "path".
        Then put this new <path> element into a <group> with the supplied
        node.  This means making a new <group> element and making the
        node a child of it with the new <path> as a sibling.
        """

        if (not path) or (len(path) == 0):
            return

        if make_group:
            # Make a new SVG <group> element whose parent is the parent of node
            parent = node.getparent()
            # was: if not parent:
            if parent is None:
                parent = self.document.getroot()
            g = etree.SubElement(parent, inkex.addNS('g', 'svg'))

            # Move node to be a child of this new <g> element
            g.append(node)

            # Promote the node's transform to the new parent group
            # This way, it will apply to the original paths and the
            # "twisted" paths
            transform = node.get('transform')
            if transform:
                g.set('transform', transform)
                del node.attrib['transform']
        else:
            g = node.getparent()

        # Now make a <path> element which contains the twist & is a child
        # of the new <g> element
        style = {'stroke': '#000000', 'fill': 'none', 'stroke-width': '1'}
        line_attribs = {'style': str(inkex.Style(style)), 'd': path}
        if (clone_transform is not None) and (clone_transform != ''):
            line_attribs['transform'] = clone_transform
        etree.SubElement(g, inkex.addNS('path', 'svg'), line_attribs)

    def twist(self, ratio):

        if not self.paths:
            return

        # Now iterate over all of the polygons
        for path in self.paths:
            for subpath in self.paths[path]:
                for i in range(len(subpath) - 1):
                    x = subpath[i][0] + ratio * (subpath[i + 1][0] - subpath[i][0])
                    y = subpath[i][1] + ratio * (subpath[i + 1][1] - subpath[i][1])
                    subpath[i] = [x, y]
                subpath[-1] = subpath[0]

    def draw(self, make_group=False):

        """
        Draw the edges of the current list of vertices
        """

        if not self.paths:
            return

        # Now iterate over all of the polygons
        for path in self.paths:
            for subpath in self.paths[path]:
                pdata = ''
                for vertex in subpath:
                    if pdata == '':
                        pdata = 'M {:f},{:f}'.format(vertex[0], vertex[1])
                    else:
                        pdata += ' L {:f},{:f}'.format(vertex[0], vertex[1])
                self.joinWithNode(path, pdata, make_group, self.paths_clone_transform[path])

    def effect(self):

        # Build a list of the vertices for the document's graphical elements
        if self.options.ids:
            # Traverse the selected objects
            for id_ in self.options.ids:
#                self.recursivelyTraverseSvg([self.svg.selected[id_]])
                self.recursivelyTraverseSvg([self.svg.getElementById(id_)])
        else:
            # Traverse the entire document
            self.recursivelyTraverseSvg(self.document.getroot())

        # Now iterate over the vertices N times
        for n in range(self.options.nSteps):
            self.twist(self.options.fRatio)
            self.draw(n == 0)


if __name__ == '__main__':
    Twist().run()