picosvgx 0.1.0__py3-none-any.whl

picosvgx/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__version__ = "0.1.0"

picosvgx/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.dev659+g00f0aab4b.d20260206'
+__version_tuple__ = version_tuple = (0, 1, 'dev659', 'g00f0aab4b.d20260206')
+
+__commit_id__ = commit_id = 'g00f0aab4b'

picosvgx/arc_to_cubic.py

@@ -0,0 +1,210 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Convert SVG Path's elliptical arcs to Bezier curves.
+
+The code is adapted from FontTools fontTools/svgLib/path/arc.py, which in turn
+is adapted from Blink's SVGPathNormalizer::DecomposeArcToCubic:
+https://github.com/chromium/chromium/blob/93831f2/third_party/blink/renderer/core/svg/svg_path_parser.cc#L169-L278
+"""
+from math import atan2, ceil, cos, fabs, isfinite, pi, radians, sin, sqrt, tan
+from typing import Iterator, NamedTuple, Optional, Tuple
+from picosvgx.geometric_types import Point, Vector
+from picosvgx.svg_transform import Affine2D
+
+
+TWO_PI = 2 * pi
+PI_OVER_TWO = 0.5 * pi
+
+
+class CenterParametrization(NamedTuple):
+    theta1: float
+    theta_arc: float
+    center_point: Point
+
+
+class EllipticalArc(NamedTuple):
+    start_point: Point
+    rx: float
+    ry: float
+    rotation: float
+    large: int
+    sweep: int
+    end_point: Point
+
+    def is_straight_line(self) -> bool:
+        # If rx = 0 or ry = 0 then this arc is treated as a straight line segment (a
+        # "lineto") joining the endpoints.
+        # http://www.w3.org/TR/SVG/implnote.html#ArcOutOfRangeParameters
+        rx = fabs(self.rx)
+        ry = fabs(self.ry)
+        if not (rx and ry):
+            return True
+        return False
+
+    def is_zero_length(self):
+        return self.end_point == self.start_point
+
+    def correct_out_of_range_radii(self) -> "EllipticalArc":
+        # Check if the radii are big enough to draw the arc, scale radii if not.
+        # http://www.w3.org/TR/SVG/implnote.html#ArcCorrectionOutOfRangeRadii
+        if self.is_straight_line() or self.is_zero_length():
+            return self
+
+        mid_point_distance = (self.start_point - self.end_point) * 0.5
+
+        # SVG rotation is expressed in degrees, whereas Affin2D.rotate uses radians
+        angle = radians(self.rotation)
+        point_transform = Affine2D.identity().rotate(-angle)
+
+        transformed_mid_point = point_transform.map_vector(mid_point_distance)
+        rx = self.rx
+        ry = self.ry
+        square_rx = rx * rx
+        square_ry = ry * ry
+        square_x = transformed_mid_point.x * transformed_mid_point.x
+        square_y = transformed_mid_point.y * transformed_mid_point.y
+
+        radii_scale = square_x / square_rx + square_y / square_ry
+        if radii_scale > 1:
+            rx *= sqrt(radii_scale)
+            ry *= sqrt(radii_scale)
+            return self._replace(rx=rx, ry=ry)
+
+        return self
+
+    # https://www.w3.org/TR/SVG/implnote.html#ArcConversionEndpointToCenter
+    def end_to_center_parametrization(self) -> CenterParametrization:
+        if self.is_straight_line() or self.is_zero_length():
+            raise ValueError(f"Can't compute center parametrization for {self}")
+
+        angle = radians(self.rotation)
+        point_transform = (
+            Affine2D.identity().scale(1 / self.rx, 1 / self.ry).rotate(-angle)
+        )
+
+        point1 = point_transform.map_point(self.start_point)
+        point2 = point_transform.map_point(self.end_point)
+        delta = point2 - point1
+
+        d = delta.x * delta.x + delta.y * delta.y
+        scale_factor_squared = max(1 / d - 0.25, 0.0)
+
+        scale_factor = sqrt(scale_factor_squared)
+        if self.sweep == self.large:
+            scale_factor = -scale_factor
+
+        delta *= scale_factor
+        center_point = point1 + (point2 - point1) * 0.5 + Vector(-delta.y, delta.x)
+        v1 = point1 - center_point
+        v2 = point2 - center_point
+
+        theta1 = atan2(v1.y, v1.x)
+        theta2 = atan2(v2.y, v2.x)
+
+        theta_arc = theta2 - theta1
+        if theta_arc < 0 and self.sweep:
+            theta_arc += TWO_PI
+        elif theta_arc > 0 and not self.sweep:
+            theta_arc -= TWO_PI
+
+        center_point = point_transform.inverse().map_point(center_point)
+
+        return CenterParametrization(theta1, theta_arc, center_point)
+
+
+def _arc_to_cubic(arc: EllipticalArc) -> Iterator[Tuple[Point, Point, Point]]:
+    arc = arc.correct_out_of_range_radii()
+    arc_params = arc.end_to_center_parametrization()
+
+    point_transform = (
+        Affine2D.identity()
+        .translate(arc_params.center_point.x, arc_params.center_point.y)
+        .rotate(radians(arc.rotation))
+        .scale(arc.rx, arc.ry)
+    )
+
+    # Some results of atan2 on some platform implementations are not exact
+    # enough. So that we get more cubic curves than expected here. Adding 0.001f
+    # reduces the count of sgements to the correct count.
+    num_segments = int(ceil(fabs(arc_params.theta_arc / (PI_OVER_TWO + 0.001))))
+    for i in range(num_segments):
+        start_theta = arc_params.theta1 + i * arc_params.theta_arc / num_segments
+        end_theta = arc_params.theta1 + (i + 1) * arc_params.theta_arc / num_segments
+
+        t = (4 / 3) * tan(0.25 * (end_theta - start_theta))
+        if not isfinite(t):
+            return
+
+        sin_start_theta = sin(start_theta)
+        cos_start_theta = cos(start_theta)
+        sin_end_theta = sin(end_theta)
+        cos_end_theta = cos(end_theta)
+
+        point1 = Point(
+            cos_start_theta - t * sin_start_theta, sin_start_theta + t * cos_start_theta
+        )
+        end_point = Point(cos_end_theta, sin_end_theta)
+        point2 = end_point + Vector(t * sin_end_theta, -t * cos_end_theta)
+
+        point1 = point_transform.map_point(point1)
+        point2 = point_transform.map_point(point2)
+
+        # by definition, the last bezier's end point == the arc end point
+        # by directly taking the end point we avoid floating point imprecision
+        if i == num_segments - 1:
+            end_point = arc.end_point
+        else:
+            end_point = point_transform.map_point(end_point)
+
+        yield point1, point2, end_point
+
+
+def arc_to_cubic(
+    start_point: Tuple[float, float],
+    rx: float,
+    ry: float,
+    rotation: float,
+    large: int,
+    sweep: int,
+    end_point: Tuple[float, float],
+) -> Iterator[Tuple[Optional[Point], Optional[Point], Point]]:
+    """Convert arc to cubic(s).
+
+    start/end point are (x,y) tuples with absolute coordinates.
+    See https://skia.org/user/api/SkPath_Reference#SkPath_arcTo_4
+    Note in particular:
+        SVG sweep-flag value is opposite the integer value of sweep;
+        SVG sweep-flag uses 1 for clockwise, while kCW_Direction cast to int is zero.
+
+    Yields 3-tuples of Points for each Cubic bezier, i.e. two off-curve points and
+    one on-curve end point.
+
+    If either rx or ry is 0, the arc is treated as a straight line joining the end
+    points, and a (None, None, arc.end_point) tuple is yielded.
+
+    Yields empty iterator if arc has zero length.
+    """
+    if not isinstance(start_point, Point):
+        start_point = Point(*start_point)
+    if not isinstance(end_point, Point):
+        end_point = Point(*end_point)
+
+    arc = EllipticalArc(start_point, rx, ry, rotation, large, sweep, end_point)
+    if arc.is_zero_length():
+        return
+    elif arc.is_straight_line():
+        yield None, None, arc.end_point
+    else:
+        yield from _arc_to_cubic(arc)

picosvgx/geometric_types.py

@@ -0,0 +1,170 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+from typing import NamedTuple, Optional, Union
+
+
+DEFAULT_ALMOST_EQUAL_TOLERANCE = 1e-9
+_PointOrVec = Union["Point", "Vector"]
+
+
+def almost_equal(c1, c2, tolerance=DEFAULT_ALMOST_EQUAL_TOLERANCE) -> bool:
+    return abs(c1 - c2) <= tolerance
+
+
+class Point(NamedTuple):
+    x: float = 0
+    y: float = 0
+
+    def _sub_pt(self, other: "Point") -> "Vector":
+        return Vector(self.x - other.x, self.y - other.y)
+
+    def _sub_vec(self, other: "Vector") -> "Point":
+        return self.__class__(self.x - other.x, self.y - other.y)
+
+    def __sub__(self, other: _PointOrVec) -> _PointOrVec:
+        """Return a Point or Vector based on the type of other.
+
+        If other is a Point, return Vector from other to self.
+        If other is a Vector, return Point translated by -other Vector.
+        """
+        if isinstance(other, Point):
+            return self._sub_pt(other)
+        elif isinstance(other, Vector):
+            return self._sub_vec(other)
+        return NotImplemented  # pytype: disable=bad-return-type
+
+    def __add__(self, other: "Vector") -> "Point":
+        """Return Point translated by other Vector"""
+        if isinstance(other, Vector):
+            return self.__class__(self.x + other.x, self.y + other.y)
+        return NotImplemented  # pytype: disable=bad-return-type
+
+    def round(self, digits: int) -> "Point":
+        return Point(round(self.x, digits), round(self.y, digits))
+
+    def almost_equals(
+        self, other: "Point", tolerance=DEFAULT_ALMOST_EQUAL_TOLERANCE
+    ) -> bool:
+        return almost_equal(self.x, other.x, tolerance) and almost_equal(
+            self.y, other.y, tolerance
+        )
+
+
+class Vector(NamedTuple):
+    x: float = 0
+    y: float = 0
+
+    def __add__(self, other: "Vector") -> "Vector":
+        return self.__class__(self.x + other.x, self.y + other.y)
+
+    def __sub__(self, other: "Vector") -> "Vector":
+        return self.__class__(self.x - other.x, self.y - other.y)
+
+    def __neg__(self) -> "Vector":
+        return self * -1.0
+
+    def __mul__(self, scalar: float) -> "Vector":
+        """Multiply vector by a scalar value."""
+        if not isinstance(scalar, (int, float)):
+            return NotImplemented
+        return self.__class__(self.x * scalar, self.y * scalar)
+
+    __rmul__ = __mul__
+
+    def perpendicular(self, clockwise: bool = False) -> "Vector":
+        """Return Vector rotated 90 degrees counter-clockwise from self.
+
+        If clockwise is True, return the other perpendicular vector.
+        """
+        # https://mathworld.wolfram.com/PerpendicularVector.html
+        if clockwise:
+            return self.__class__(self.y, -self.x)
+        else:
+            return self.__class__(-self.y, self.x)
+
+    def norm(self) -> float:
+        """Return the vector Euclidean norm (or length or magnitude)."""
+        return math.sqrt(self.x * self.x + self.y * self.y)
+
+    def unit(self) -> Optional["Vector"]:
+        """Return the Unit Vector (of length 1), or None if self is a zero vector."""
+        norm = self.norm()
+        if norm != 0:
+            return self.__class__(self.x / norm, self.y / norm)
+        return None
+
+    def dot(self, other: "Vector") -> float:
+        """Return the Dot Product of self with other vector."""
+        return self.x * other.x + self.y * other.y
+
+    def projection(self, other: "Vector") -> "Vector":
+        """Return the vector projection of self onto other vector."""
+        norm = other.norm()
+        if norm == 0:
+            # it is more helpful for projection onto 0 to be 0 than an error
+            return Vector()
+        return self.dot(other) / norm * other.unit()
+
+    def almost_equals(
+        self, other: "Vector", tolerance=DEFAULT_ALMOST_EQUAL_TOLERANCE
+    ) -> bool:
+        return almost_equal(self.x, other.x, tolerance) and almost_equal(
+            self.y, other.y, tolerance
+        )
+
+
+class Rect(NamedTuple):
+    x: float = 0
+    y: float = 0
+    w: float = 0
+    h: float = 0
+
+    def empty(self) -> bool:
+        """Return True if the Rect's width or height is 0."""
+        return self.w == 0 or self.h == 0
+
+    def intersection(self, other: "Rect") -> Optional["Rect"]:
+        def _overlap(start1, end1, start2, end2):
+            start = max(start1, start2)
+            end = min(end1, end2)
+            if start >= end:
+                return (0.0, 0.0)
+            return (start, end)
+
+        x1, x2 = _overlap(self.x, self.x + self.w, other.x, other.x + other.w)
+        y1, y2 = _overlap(self.y, self.y + self.h, other.y, other.y + other.h)
+
+        if x1 != x2 and y1 != y2:
+            return Rect(x1, y1, x2 - x1, y2 - y1)
+        return None
+
+    @property
+    def x_max(self) -> float:
+        return self.x + self.w
+
+    @property
+    def y_max(self) -> float:
+        return self.y + self.h
+
+    def union(self, other: "Rect") -> "Rect":
+        x, y = min(self.x, other.x), min(self.y, other.y)
+        x_max, y_max = max(self.x_max, other.x_max), max(self.y_max, other.y_max)
+        return Rect(x=x, y=y, w=x_max - x, h=y_max - y)
+
+    def normalized_diagonal(self):
+        # used for computing percentages of lengths relative to the SVG viewport:
+        # https://www.w3.org/TR/SVG2/coords.html#Units
+        return math.hypot(self.w, self.h) / math.sqrt(2)

picosvgx/picosvgx.py

@@ -0,0 +1,85 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Simplify svg.
+
+Usage:
+picosvg.py emoji_u1f469_1f3fd_200d_1f91d_200d_1f468_1f3fb.svg
+<simplified svg dumped to stdout>
+"""
+from absl import app
+from absl import flags
+from lxml import etree  # pytype: disable=import-error
+from picosvgx.svg import SVG
+from picosvgx.svg_meta import svgns
+import sys
+
+
+FLAGS = flags.FLAGS
+
+
+flags.DEFINE_bool(
+    "drop_unsupported",
+    False,
+    "Whether to blindly discard all elements we don't understand. Likely unwise.",
+)
+flags.DEFINE_bool("clip_to_viewbox", False, "Whether to clip content outside viewbox")
+flags.DEFINE_string("output_file", "-", "Output SVG file ('-' means stdout)")
+flags.DEFINE_bool(
+    "allow_text",
+    False,
+    "Whether to allow text elements. Note that they will not be converted to paths, just pass through to the output.",
+)
+flags.DEFINE_bool(
+    "allow_all_defs",
+    False,
+    "Allow all defs elements (filter, mask, pattern, etc.) and root-level switch/symbol to pass through.",
+)
+
+
+def _run(argv):
+    try:
+        input_file = argv[1]
+    except IndexError:
+        input_file = None
+
+    if input_file:
+        svg = SVG.parse(input_file)
+    else:
+        svg = SVG.fromstring(sys.stdin.read())
+
+    # Do the needful
+    svg = svg.topicosvg(
+        allow_text=FLAGS.allow_text, allow_all_defs=FLAGS.allow_all_defs, drop_unsupported=FLAGS.drop_unsupported
+    )
+
+    if FLAGS.clip_to_viewbox:
+        svg.clip_to_viewbox(inplace=True)
+
+    output = svg.tostring(pretty_print=True)
+
+    if FLAGS.output_file == "-":
+        print(output)
+    else:
+        with open(FLAGS.output_file, "w") as f:
+            f.write(output)
+
+
+def main(argv=None):
+    # We don't seem to be __main__ when run as cli tool installed by setuptools
+    app.run(_run, argv=argv)
+
+
+if __name__ == "__main__":
+    main()