Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 226 insertions, 0 deletions

diff --git a/share/extensions/pathmodifier.py b/share/extensions/pathmodifier.py
new file mode 100755
index 0000000..e99b4b5
--- /dev/null
+++ b/share/extensions/pathmodifier.py
@@ -0,0 +1,226 @@
+#!/usr/bin/env python
+# coding=utf-8
+#
+# Copyright (C) 2006 Jean-Francois Barraud, barraud@math.univ-lille1.fr
+#               2021 Jonathan Neuhauser, jonathan.neuhauser@outlook.com
+#
+# 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+# barraud@math.univ-lille1.fr
+#
+"""
+This code defines a basic class (PathModifier) of effects whose purpose is
+to somehow deform given objects: one common tasks for all such effect is to
+convert shapes, groups, clones to paths. The class has several functions to
+make this (more or less!) easy.
+As an example, a second class (Diffeo) is derived from it,
+to implement deformations of the form X=f(x,y), Y=g(x,y)...
+"""
+
+import inkex
+from inkex import PathElement, Group, Use
+from inkex.bezier import pointdistance, beziersplitatt
+
+# This deprecated API is used by some external extensions.
+from inkex.deprecated import zSort  # pylint: disable=unused-import
+
+
+class PathModifier(inkex.EffectExtension):
+    """Select list manipulation"""
+
+    def expand_groups(self, elements, transferTransform=True):
+        for node_id, node in list(elements.items()):
+            if isinstance(node, inkex.Group):
+                mat = node.transform
+                for child in node:
+                    if transferTransform:
+                        child.transform = mat @ child.transform
+                    elements.update(self.expand_groups({child.get("id"): child}))
+                if transferTransform and node.get("transform"):
+                    del node.attrib["transform"]
+                # Group is now replaced, so remove it.
+                elements.pop(node_id)
+        return elements
+
+    def expand_clones(self, elements, transferTransform=True, replace=True):
+        for node_id, node in list(elements.items()):
+            if isinstance(node, Group):
+                self.expand_groups(elements, transferTransform)
+                self.expand_clones(elements, transferTransform, replace)
+                # Hum... not very efficient if there are many clones of groups...
+
+            elif isinstance(node, Use):
+                newnode = node.unlink()
+                elements.pop(node_id)
+                newid = newnode.get("id")
+                elements.update(
+                    self.expand_clones({newid: newnode}, transferTransform, replace)
+                )
+        return elements
+
+    def objects_to_paths(self, elements, replace=True):
+        """Replace all non-paths with path objects"""
+        for node in list(elements.values()):
+            elem = node.to_path_element()
+            if replace:
+                node.replace_with(elem)
+                elem.set("id", node.get("id"))
+            elements[elem.get("id")] = elem
+
+    def effect(self):
+        raise NotImplementedError("overwrite this method in subclasses")
+        self.objects_to_paths(self.svg.selection, True)
+        self.bbox = self.svg.selection.bounding_box()
+        for node in self.svg.selection.filter(PathElement):
+            path = node.path.to_superpath()
+            # do what ever you want with "path"!
+            node.path = path
+
+    @staticmethod
+    def lengthtotime(l, lengths, isclosed):
+        """
+        Receives an arc length l, and returns the index of the segment in skelcomp
+        containing the corresponding point, to gether with the position of the point on this segment.
+
+        If the deformer is closed, do computations modulo the toal length.
+        """
+        if isclosed:
+            l = l % sum(lengths)
+        if l <= 0:
+            return 0, l / lengths[0]
+        i = 0
+        while (i < len(lengths)) and (lengths[i] <= l):
+            l -= lengths[i]
+            i += 1
+        t = l / lengths[min(i, len(lengths) - 1)]
+        return i, t
+
+    @staticmethod
+    def flipxy(path):
+        """Swaps x and y coordinate of all path vertices"""
+        for pathcomp in path:
+            for ctl in pathcomp:
+                for pt in ctl:
+                    tmp = pt[0]
+                    pt[0] = -pt[1]
+                    pt[1] = -tmp
+
+    @staticmethod
+    def offset(pathcomp, dx, dy):
+        """Shifts a subpath by (dx, dy)"""
+        for ctl in pathcomp:
+            for pt in ctl:
+                pt[0] += dx
+                pt[1] += dy
+
+    @staticmethod
+    def stretch(pathcomp, xscale, yscale, org):
+        """Stretches a subpath by (xscale, yscale) relative to origin org"""
+        for ctl in pathcomp:
+            for pt in ctl:
+                pt[0] = org[0] + (pt[0] - org[0]) * xscale
+                pt[1] = org[1] + (pt[1] - org[1]) * yscale
+
+    @staticmethod
+    def linearize(p, tolerance=0.001):
+        """
+        This function receives a component of a 'cubicsuperpath' and returns two things:
+        The path subdivided in many straight segments, and an array containing the length of each segment.
+
+        We could work with bezier path as well, but bezier arc lengths are (re)computed for each point
+        in the deformed object. For complex paths, this might take a while.
+        """
+        zero = 0.000001
+        i = 0
+        d = 0
+        lengths = []
+        while i < len(p) - 1:
+            box = pointdistance(p[i][1], p[i][2])
+            box += pointdistance(p[i][2], p[i + 1][0])
+            box += pointdistance(p[i + 1][0], p[i + 1][1])
+            chord = pointdistance(p[i][1], p[i + 1][1])
+            if (box - chord) > tolerance:
+                b1, b2 = beziersplitatt(
+                    [p[i][1], p[i][2], p[i + 1][0], p[i + 1][1]], 0.5
+                )
+                p[i][2][0], p[i][2][1] = b1[1]
+                p[i + 1][0][0], p[i + 1][0][1] = b2[2]
+                p.insert(
+                    i + 1,
+                    [[b1[2][0], b1[2][1]], [b1[3][0], b1[3][1]], [b2[1][0], b2[1][1]]],
+                )
+            else:
+                d = (box + chord) / 2
+                lengths.append(d)
+                i += 1
+        new = [p[i][1] for i in range(0, len(p) - 1) if lengths[i] > zero]
+        new.append(p[-1][1])
+        lengths = [l for l in lengths if l > zero]
+        return new, lengths
+
+    def get_patterns_and_skeletons(self, expand_patterns=False, duplicate=False):
+        """Gets the pattern node and skeleton (with applied transforms) from selection"""
+        # first selected->pattern, all but first selected-> skeletons
+        skeletons = self.svg.selection.rendering_order()
+
+        elem = skeletons.pop()
+        if duplicate:
+            elem = elem.duplicate()
+
+        if expand_patterns:
+            patterns = {elem.get_id(): elem}
+            self.expand_clones(patterns, True, False)
+            self.objects_to_paths(patterns)
+        else:
+            patterns = elem
+
+        self.expand_clones(skeletons, True, False)
+        self.objects_to_paths(skeletons)
+        return patterns, skeletons.id_dict()
+
+
+class Diffeo(PathModifier):
+    def applyDiffeo(self, bpt, vects=()):
+        # bpt is a base point and for v in vectors, v'=v-p is a tangent vector at bpt.
+        # Defaults to identity!
+        for v in vects:
+            v[0] -= bpt[0]
+            v[1] -= bpt[1]
+
+        # -- your transformations go here:
+        # x,y=bpt
+        # bpt[0]=f(x,y)
+        # bpt[1]=g(x,y)
+        # for v in vects:
+        #    vx,vy=v
+        #    v[0]=df/dx(x,y)*vx+df/dy(x,y)*vy
+        #    v[1]=dg/dx(x,y)*vx+dg/dy(x,y)*vy
+        #
+        # -- !caution! y-axis is pointing downward!
+
+        for v in vects:
+            v[0] += bpt[0]
+            v[1] += bpt[1]
+
+    def effect(self):
+        self.expand_clones(self.svg.selection, True)
+        self.expand_groups(self.svg.selection, True)
+        self.objects_to_paths(self.svg.selection, True)
+        self.bbox = self.svg.selection.bounding_box()
+        for node in self.svg.selection.filter(PathElement):
+            path = node.path.to_superpath()
+            for sub in path:
+                for ctlpt in sub:
+                    self.applyDiffeo(ctlpt[1], (ctlpt[0], ctlpt[2]))
+            node.path = path