Adding upstream version 1.2.2.upstream/1.2.2upstream

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

1 files changed, 501 insertions, 0 deletions

diff --git a/share/extensions/pixelsnap.py b/share/extensions/pixelsnap.py
new file mode 100755
index 0000000..e414af6
--- /dev/null
+++ b/share/extensions/pixelsnap.py
@@ -0,0 +1,501 @@
+#!/usr/bin/env python
+# coding=utf-8
+#
+# Copyright (c) 2009 Bryan Hoyt (MIT License)
+#               2011 Nicolas Dufour <nicoduf@yahoo.fr>
+#               2013 Johan B. C. Engelen <j.b.c.engelen@alumnus.utwente.nl>
+#               2019 Martin Owens <doctormo@gmail.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.
+#
+"""
+TODO: mark elements that have previously been snapped, along with the settings
+    used, so that the same settings can be used for that element next time when
+    it's selected as part of a group (and add an option to the extension dialog
+    "Use previous/default settings" which is selected by default)
+
+TODO: make elem_offset return [x_offset, y_offset] so we can handle non-symetric scaling
+      => will probably need to take into account non-symetric scaling on stroke-widths,
+         too (horizontal vs vertical strokes)
+
+TODO: Transforming points isn't quite perfect, to say the least. In particular,
+    when translating a point on a bezier curve, we translate the handles by the same amount.
+    BUT, some handles that are attached to a particular point are conceptually
+    handles of the prev/next node.
+    Best way to fix it would be to keep a list of the fractional_offsets[] of
+    each point, without transforming anything. Then go through each point and
+    transform the appropriate handle according to the relevant fraction_offset
+    in the list.
+
+    i.e. calculate first, then modify.
+
+    In fact, that might be a simpler algorithm anyway -- it avoids having
+    to keep track of all the first_xy/next_xy guff.
+
+Note: This doesn't work very well on paths which have both straight segments
+      and curved segments.
+      The biggest three problems are:
+        a) we don't take handles into account (segments where the nodes are
+           aligned are always treated as straight segments, even where the
+           handles make it curve)
+        b) when we snap a straight segment right before/after a curve, it
+           doesn't make any attempt to keep the transition from the straight
+           segment to the curve smooth.
+        c) no attempt is made to keep equal widths equal. (or nearly-equal
+           widths nearly-equal). For example, font strokes.
+
+Note: Paths that have curves & arcs on some sides of the bounding box won't
+    be snapped correctly on that side of the bounding box, and nor will they
+    be translated/resized correctly before the path is modified. Doesn't affect
+    most applications of this extension, but it highlights the fact that we
+    take a geometrically simplistic approach to inspecting & modifying the path.
+"""
+
+from __future__ import division
+from __future__ import print_function
+
+import sys
+
+import inkex
+from inkex import PathElement, Group, Image, Rectangle, ShapeElement, Transform
+from inkex.localization import inkex_gettext as _
+
+Precision = 5  # number of digits of precision for comparing float numbers
+
+
+class TransformError(Exception):
+    pass
+
+
+def transform_point(transform, pt, inverse=False):
+    """apply_to_point with inbuilt inverse"""
+    if inverse:
+        transform = -transform
+    return transform.apply_to_point(pt)
+
+
+def transform_dimensions(transform, width=None, height=None, inverse=False):
+    """Dimensions don't get translated. I'm not sure how much diff rotate/skew
+    makes in this context, but we currently ignore anything besides scale.
+    """
+    if inverse:
+        transform = -transform
+
+    if width is not None:
+        width *= transform.a
+    if height is not None:
+        height *= transform.d
+
+    if width is not None and height is not None:
+        return width, height
+    if width is not None:
+        return width
+    if height is not None:
+        return height
+
+
+class PixelSnap(inkex.EffectExtension):
+    """Snap objects to pixels"""
+
+    def add_arguments(self, pars):
+        """Add inx options"""
+        pars.add_argument(
+            "-a",
+            "--snap_ancestors",
+            type=inkex.Boolean,
+            default=True,
+            help="Snap unselected ancestors' translations "
+            "(groups, layers, document height) first",
+        )
+        pars.add_argument(
+            "-t",
+            "--ancestor_offset",
+            type=inkex.Boolean,
+            default=True,
+            help="Calculate offset relative to unselected ancestors' "
+            "transforms (includes document height offset)",
+        )
+        pars.add_argument(
+            "-g",
+            "--max_gradient",
+            type=float,
+            default=0.5,
+            help="Maximum slope to consider straight (%)",
+        )
+        pars.add_argument(
+            "-s",
+            "--snap_to",
+            default="tl",
+            choices=["tl", "bl"],
+            help="Origin of the coordinate system",
+        )
+
+    def vertical(self, pt1, pt2):
+        hlen = abs(pt1[0] - pt2[0])
+        vlen = abs(pt1[1] - pt2[1])
+        if vlen == 0 and hlen == 0:
+            return True
+        elif vlen == 0:
+            return False
+        return (hlen / vlen) < self.options.max_gradient / 100
+
+    def horizontal(self, pt1, pt2):
+        hlen = round(abs(pt1[0] - pt2[0]), Precision)
+        vlen = round(abs(pt1[1] - pt2[1]), Precision)
+        if hlen == 0 and vlen == 0:
+            return True
+        elif hlen == 0:
+            return False
+        return (vlen / hlen) < self.options.max_gradient / 100
+
+    def stroke_width_offset(self, elem, parent_transform=None):
+        """Returns the amount the bounding-box is offset due to the stroke-width.
+        Transform is taken into account.
+        """
+        stroke_width = self.stroke_width(elem)
+        if stroke_width == 0:
+            return 0  # if there's no stroke, no need to worry about the transform
+
+        transform = elem.transform @ Transform(parent_transform)
+
+        if abs(abs(transform.a) - abs(transform.d)) > (10**-Precision):
+            raise TransformError(
+                _("Selection contains non-symetric scaling")
+            )  # *** wouldn't be hard to get around this by calculating vertical_offset & horizontal_offset separately, maybe 1 functions, or maybe returning a tuple
+
+        stroke_width = transform_dimensions(transform, width=stroke_width)
+
+        return stroke_width / 2
+
+    def stroke_width(self, elem, setval=None):
+        """Get/set stroke-width in pixels, untransformed"""
+        style = elem.style
+        stroke = style("stroke")
+
+        stroke_width = 0
+        if stroke and setval is None:
+            stroke_width = self.svg.to_dimensionless(style("stroke-width").strip())
+
+        if setval:
+            style["stroke-width"] = setval
+        else:
+            return stroke_width
+
+    def transform_path_node(self, transform, path, i):
+        """Modifies a segment so that every point is transformed, including handles"""
+        segtype = path[i][0].lower()
+
+        if segtype == "z":
+            return
+        elif segtype == "h":
+            path[i][1][0] = transform_point(transform, [path[i][1][0], 0])[0]
+        elif segtype == "v":
+            path[i][1][0] = transform_point(transform, [0, path[i][1][0]])[1]
+        else:
+            first_coordinate = 0
+            if segtype == "a":
+                first_coordinate = 5  # for elliptical arcs, skip the radius x/y, rotation, large-arc, and sweep
+            for j in range(first_coordinate, len(path[i][1]), 2):
+                x, y = path[i][1][j], path[i][1][j + 1]
+                x, y = transform_point(transform, (x, y))
+                path[i][1][j] = x
+                path[i][1][j + 1] = y
+
+    def pathxy(self, path, i, setval=None):
+        """Return the endpoint of the given path segment.
+        Inspects the segment type to know which elements are the endpoints.
+        """
+        segtype = path[i][0].lower()
+        x = y = 0
+
+        if segtype == "z":
+            i = 0
+
+        if segtype == "h":
+            if setval:
+                path[i][1][0] = setval[0]
+            else:
+                x = path[i][1][0]
+
+        elif segtype == "v":
+            if setval:
+                path[i][1][0] = setval[1]
+            else:
+                y = path[i][1][0]
+        else:
+            if setval and segtype != "z":
+                path[i][1][-2] = setval[0]
+                path[i][1][-1] = setval[1]
+            else:
+                x = path[i][1][-2]
+                y = path[i][1][-1]
+
+        if setval is None:
+            return [x, y]
+
+    def snap_path_scale(self, elem, parent_transform=None):
+
+        path = elem.original_path.to_arrays()
+        transform = elem.transform @ Transform(parent_transform)
+        bbox = elem.bounding_box()
+
+        # In case somebody tries to snap a 0-high element,
+        # or a curve/arc with all nodes in a line, and of course
+        # because we should always check for divide-by-zero!
+        if not bbox.width or not bbox.height:
+            return
+
+        width, height = bbox.width, bbox.height
+        min_xy, max_xy = bbox.minimum, bbox.maximum
+        rescale = round(width) / width, round(height) / height
+
+        min_xy = transform_point(transform, min_xy, inverse=True)
+        max_xy = transform_point(transform, max_xy, inverse=True)
+
+        for i in range(len(path)):
+            translate = Transform(translate=min_xy)
+            self.transform_path_node(-translate, path, i)  # center transform
+            self.transform_path_node(Transform(scale=rescale), path, i)
+            self.transform_path_node(translate, path, i)  # uncenter transform
+
+        elem.original_path = path
+
+    def snap_path_pos(self, elem, parent_transform=None):
+        path = elem.original_path.to_arrays()
+        transform = elem.transform @ Transform(parent_transform)
+        bbox = elem.bounding_box()
+        min_xy, max_xy = bbox.minimum, bbox.maximum
+
+        fractional_offset = (
+            min_xy[0] - round(min_xy[0]),
+            min_xy[1] - round(min_xy[1]) - self.document_offset,
+        )
+        fractional_offset = transform_dimensions(
+            transform, fractional_offset[0], fractional_offset[1], inverse=True
+        )
+
+        for i in range(len(path)):
+            self.transform_path_node(-Transform(translate=fractional_offset), path, i)
+
+        path = str(inkex.Path(path))
+        if elem.get("inkscape:original-d"):
+            elem.set("inkscape:original-d", path)
+        else:
+            elem.set("d", path)
+
+    def snap_transform(self, elem):
+        # Only snaps the x/y translation of the transform, nothing else.
+        # Doesn't take any parent_transform into account -- assumes
+        # that the parent's transform has already been snapped.
+        transform = elem.transform
+        # if we've got any skew/rotation, get outta here
+        if transform.c or transform.b:
+            raise TransformError(
+                _("TR: Selection contains transformations with skew/rotation")
+            )
+
+        trm = list(transform.to_hexad())
+        trm[4] = round(transform.e)
+        trm[5] = round(transform.f)
+        elem.transform @= Transform(trm)
+
+    def snap_stroke(self, elem, parent_transform=None):
+        transform = elem.transform @ Transform(parent_transform)
+
+        stroke_width = self.stroke_width(elem)
+        if stroke_width == 0:
+            return  # no point raising a TransformError if there's no stroke to snap
+
+        if abs(abs(transform.a) - abs(transform.d)) > (10**-Precision):
+            raise TransformError(
+                _("Selection contains non-symetric scaling, can't snap stroke width")
+            )
+
+        if stroke_width:
+            stroke_width = transform_dimensions(transform, width=stroke_width)
+            stroke_width = round(stroke_width)
+            stroke_width = transform_dimensions(
+                transform, width=stroke_width, inverse=True
+            )
+            self.stroke_width(elem, stroke_width)
+
+    def snap_path(self, elem, parent_transform=None):
+        path = elem.original_path.to_arrays()
+
+        transform = elem.transform @ Transform(parent_transform)
+
+        if transform.c or transform.b:  # if we've got any skew/rotation, get outta here
+            raise TransformError(
+                _("Path: Selection contains transformations with skew/rotation")
+            )
+
+        offset = self.stroke_width_offset(elem, parent_transform) % 1
+
+        prev_xy = self.pathxy(path, -1)
+        first_xy = self.pathxy(path, 0)
+        for i in range(len(path)):
+            segtype = path[i][0].lower()
+            xy = self.pathxy(path, i)
+            if segtype == "z":
+                xy = first_xy
+            if (i == len(path) - 1) or (
+                (i == len(path) - 2) and path[-1][0].lower() == "z"
+            ):
+                next_xy = first_xy
+            else:
+                next_xy = self.pathxy(path, i + 1)
+
+            if not (xy and prev_xy and next_xy):
+                prev_xy = xy
+                continue
+
+            xy_untransformed = tuple(xy)
+            xy = list(transform_point(transform, xy))
+            prev_xy = transform_point(transform, prev_xy)
+            next_xy = transform_point(transform, next_xy)
+
+            on_vertical = on_horizontal = False
+
+            if self.horizontal(xy, prev_xy):
+                # on 2-point paths, first.next==first.prev==last and last.next==last.prev==first
+                if len(path) > 2 or i == 0:
+                    # make the almost-equal values equal, so they round in the same direction
+                    xy[1] = prev_xy[1]
+                on_horizontal = True
+            if self.horizontal(xy, next_xy):
+                on_horizontal = True
+
+            if self.vertical(xy, prev_xy):  # as above
+                if len(path) > 2 or i == 0:
+                    xy[0] = prev_xy[0]
+                on_vertical = True
+            if self.vertical(xy, next_xy):
+                on_vertical = True
+
+            prev_xy = tuple(xy_untransformed)
+
+            fractional_offset = [0, 0]
+            if on_vertical:
+                fractional_offset[0] = xy[0] - (round(xy[0] - offset) + offset)
+            if on_horizontal:
+                fractional_offset[1] = (
+                    xy[1] - (round(xy[1] - offset) + offset) - self.document_offset
+                )
+
+            fractional_offset = transform_dimensions(
+                transform, fractional_offset[0], fractional_offset[1], inverse=True
+            )
+            self.transform_path_node(-Transform(translate=fractional_offset), path, i)
+
+        elem.original_path = path
+
+    def snap_rect(self, elem, parent_transform=None):
+        transform = elem.transform @ Transform(parent_transform)
+
+        if transform.c or transform.b:  # if we've got any skew/rotation, get outta here
+            raise TransformError(
+                _("Rect: Selection contains transformations with skew/rotation")
+            )
+
+        offset = self.stroke_width_offset(elem, parent_transform) % 1
+
+        width = self.svg.to_dimensionless(elem.attrib["width"])
+        height = self.svg.to_dimensionless(elem.attrib["height"])
+        x = self.svg.to_dimensionless(elem.attrib["x"])
+        y = self.svg.to_dimensionless(elem.attrib["y"])
+
+        width, height = transform_dimensions(transform, width, height)
+        x, y = transform_point(transform, [x, y])
+
+        # Snap to the nearest pixel
+        height = round(height)
+        width = round(width)
+        x = (
+            round(x - offset) + offset
+        )  # If there's a stroke of non-even width, it's shifted by half a pixel
+        y = round(y - offset) + offset
+
+        width, height = transform_dimensions(transform, width, height, inverse=True)
+        x, y = transform_point(transform, [x, y], inverse=True)
+        y += self.document_offset / transform.d
+
+        # Position the elem at the newly calculate values
+        elem.attrib["width"] = str(width)
+        elem.attrib["height"] = str(height)
+        elem.attrib["x"] = str(x)
+        elem.attrib["y"] = str(y)
+
+    def snap_image(self, elem, parent_transform=None):
+        self.snap_rect(elem, parent_transform)
+
+    def pixel_snap(self, elem, parent_transform=None):
+        if not isinstance(elem, (Group, Image, Rectangle, PathElement)):
+            return
+
+        if isinstance(elem, Group):
+            self.snap_transform(elem)
+            transform = elem.transform * Transform(parent_transform)
+            for child in elem:
+                try:
+                    self.pixel_snap(child, transform)
+                except TransformError as err:
+                    raise inkex.AbortExtension(str(err))
+            return
+
+        # If we've been given a parent_transform, we can assume that the
+        # parents have already been snapped, or don't need to be
+        if self.options.snap_ancestors and parent_transform is None:
+            # Loop through ancestors from outermost to innermost, excluding this element.
+            for child in elem.ancestors():
+                self.snap_transform(child)
+
+        # If we haven't been given a parent_transform, then we need to calculate it
+        if self.options.ancestor_offset and parent_transform is None:
+            if isinstance(elem.getparent(), ShapeElement):
+                parent_transform = elem.getparent().composed_transform()
+
+        self.snap_transform(elem)
+        try:
+            self.snap_stroke(elem, parent_transform)
+        except TransformError as err:
+            raise inkex.AbortExtension(str(err))
+
+        if isinstance(elem, PathElement):
+            self.snap_path_scale(elem, parent_transform)
+            self.snap_path_pos(elem, parent_transform)
+            self.snap_path(
+                elem, parent_transform
+            )  # would be quite useful to make this an option, as scale/pos alone doesn't mess with the path itself, and works well for sans-serif text
+        elif isinstance(elem, Rectangle):
+            self.snap_rect(elem, parent_transform)
+        elif isinstance(elem, Image):
+            self.snap_image(elem, parent_transform)
+
+    def effect(self):
+        if self.options.snap_to == "bl":
+            self.document_offset = (
+                self.svg.to_dimensionless(self.svg.get_viewbox()[3]) % 1
+            )
+        else:
+            self.document_offset = 0
+        for id, elem in self.svg.selection.items():
+            try:
+                self.pixel_snap(elem)
+            except TransformError as err:
+                raise inkex.AbortExtension(str(err))
+
+
+if __name__ == "__main__":
+    PixelSnap().run()