fonttools 4.59.1__cp314-cp314t-musllinux_1_2_aarch64.whl

fontTools/pens/cu2quPen.py

@@ -0,0 +1,325 @@
+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# 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 operator
+from fontTools.cu2qu import curve_to_quadratic, curves_to_quadratic
+from fontTools.pens.basePen import decomposeSuperBezierSegment
+from fontTools.pens.filterPen import FilterPen
+from fontTools.pens.reverseContourPen import ReverseContourPen
+from fontTools.pens.pointPen import BasePointToSegmentPen
+from fontTools.pens.pointPen import ReverseContourPointPen
+
+
+class Cu2QuPen(FilterPen):
+    """A filter pen to convert cubic bezier curves to quadratic b-splines
+    using the FontTools SegmentPen protocol.
+
+    Args:
+
+        other_pen: another SegmentPen used to draw the transformed outline.
+        max_err: maximum approximation error in font units. For optimal results,
+            if you know the UPEM of the font, we recommend setting this to a
+            value equal, or close to UPEM / 1000.
+        reverse_direction: flip the contours' direction but keep starting point.
+        stats: a dictionary counting the point numbers of quadratic segments.
+        all_quadratic: if True (default), only quadratic b-splines are generated.
+            if False, quadratic curves or cubic curves are generated depending
+            on which one is more economical.
+    """
+
+    def __init__(
+        self,
+        other_pen,
+        max_err,
+        reverse_direction=False,
+        stats=None,
+        all_quadratic=True,
+    ):
+        if reverse_direction:
+            other_pen = ReverseContourPen(other_pen)
+        super().__init__(other_pen)
+        self.max_err = max_err
+        self.stats = stats
+        self.all_quadratic = all_quadratic
+
+    def _convert_curve(self, pt1, pt2, pt3):
+        curve = (self.current_pt, pt1, pt2, pt3)
+        result = curve_to_quadratic(curve, self.max_err, self.all_quadratic)
+        if self.stats is not None:
+            n = str(len(result) - 2)
+            self.stats[n] = self.stats.get(n, 0) + 1
+        if self.all_quadratic:
+            self.qCurveTo(*result[1:])
+        else:
+            if len(result) == 3:
+                self.qCurveTo(*result[1:])
+            else:
+                assert len(result) == 4
+                super().curveTo(*result[1:])
+
+    def curveTo(self, *points):
+        n = len(points)
+        if n == 3:
+            # this is the most common case, so we special-case it
+            self._convert_curve(*points)
+        elif n > 3:
+            for segment in decomposeSuperBezierSegment(points):
+                self._convert_curve(*segment)
+        else:
+            self.qCurveTo(*points)
+
+
+class Cu2QuPointPen(BasePointToSegmentPen):
+    """A filter pen to convert cubic bezier curves to quadratic b-splines
+    using the FontTools PointPen protocol.
+
+    Args:
+        other_point_pen: another PointPen used to draw the transformed outline.
+        max_err: maximum approximation error in font units. For optimal results,
+            if you know the UPEM of the font, we recommend setting this to a
+            value equal, or close to UPEM / 1000.
+        reverse_direction: reverse the winding direction of all contours.
+        stats: a dictionary counting the point numbers of quadratic segments.
+        all_quadratic: if True (default), only quadratic b-splines are generated.
+            if False, quadratic curves or cubic curves are generated depending
+            on which one is more economical.
+    """
+
+    __points_required = {
+        "move": (1, operator.eq),
+        "line": (1, operator.eq),
+        "qcurve": (2, operator.ge),
+        "curve": (3, operator.eq),
+    }
+
+    def __init__(
+        self,
+        other_point_pen,
+        max_err,
+        reverse_direction=False,
+        stats=None,
+        all_quadratic=True,
+    ):
+        BasePointToSegmentPen.__init__(self)
+        if reverse_direction:
+            self.pen = ReverseContourPointPen(other_point_pen)
+        else:
+            self.pen = other_point_pen
+        self.max_err = max_err
+        self.stats = stats
+        self.all_quadratic = all_quadratic
+
+    def _flushContour(self, segments):
+        assert len(segments) >= 1
+        closed = segments[0][0] != "move"
+        new_segments = []
+        prev_points = segments[-1][1]
+        prev_on_curve = prev_points[-1][0]
+        for segment_type, points in segments:
+            if segment_type == "curve":
+                for sub_points in self._split_super_bezier_segments(points):
+                    on_curve, smooth, name, kwargs = sub_points[-1]
+                    bcp1, bcp2 = sub_points[0][0], sub_points[1][0]
+                    cubic = [prev_on_curve, bcp1, bcp2, on_curve]
+                    quad = curve_to_quadratic(cubic, self.max_err, self.all_quadratic)
+                    if self.stats is not None:
+                        n = str(len(quad) - 2)
+                        self.stats[n] = self.stats.get(n, 0) + 1
+                    new_points = [(pt, False, None, {}) for pt in quad[1:-1]]
+                    new_points.append((on_curve, smooth, name, kwargs))
+                    if self.all_quadratic or len(new_points) == 2:
+                        new_segments.append(["qcurve", new_points])
+                    else:
+                        new_segments.append(["curve", new_points])
+                    prev_on_curve = sub_points[-1][0]
+            else:
+                new_segments.append([segment_type, points])
+                prev_on_curve = points[-1][0]
+        if closed:
+            # the BasePointToSegmentPen.endPath method that calls _flushContour
+            # rotates the point list of closed contours so that they end with
+            # the first on-curve point. We restore the original starting point.
+            new_segments = new_segments[-1:] + new_segments[:-1]
+        self._drawPoints(new_segments)
+
+    def _split_super_bezier_segments(self, points):
+        sub_segments = []
+        # n is the number of control points
+        n = len(points) - 1
+        if n == 2:
+            # a simple bezier curve segment
+            sub_segments.append(points)
+        elif n > 2:
+            # a "super" bezier; decompose it
+            on_curve, smooth, name, kwargs = points[-1]
+            num_sub_segments = n - 1
+            for i, sub_points in enumerate(
+                decomposeSuperBezierSegment([pt for pt, _, _, _ in points])
+            ):
+                new_segment = []
+                for point in sub_points[:-1]:
+                    new_segment.append((point, False, None, {}))
+                if i == (num_sub_segments - 1):
+                    # the last on-curve keeps its original attributes
+                    new_segment.append((on_curve, smooth, name, kwargs))
+                else:
+                    # on-curves of sub-segments are always "smooth"
+                    new_segment.append((sub_points[-1], True, None, {}))
+                sub_segments.append(new_segment)
+        else:
+            raise AssertionError("expected 2 control points, found: %d" % n)
+        return sub_segments
+
+    def _drawPoints(self, segments):
+        pen = self.pen
+        pen.beginPath()
+        last_offcurves = []
+        points_required = self.__points_required
+        for i, (segment_type, points) in enumerate(segments):
+            if segment_type in points_required:
+                n, op = points_required[segment_type]
+                assert op(len(points), n), (
+                    f"illegal {segment_type!r} segment point count: "
+                    f"expected {n}, got {len(points)}"
+                )
+                offcurves = points[:-1]
+                if i == 0:
+                    # any off-curve points preceding the first on-curve
+                    # will be appended at the end of the contour
+                    last_offcurves = offcurves
+                else:
+                    for pt, smooth, name, kwargs in offcurves:
+                        pen.addPoint(pt, None, smooth, name, **kwargs)
+                pt, smooth, name, kwargs = points[-1]
+                if pt is None:
+                    assert segment_type == "qcurve"
+                    # special quadratic contour with no on-curve points:
+                    # we need to skip the "None" point. See also the Pen
+                    # protocol's qCurveTo() method and fontTools.pens.basePen
+                    pass
+                else:
+                    pen.addPoint(pt, segment_type, smooth, name, **kwargs)
+            else:
+                raise AssertionError("unexpected segment type: %r" % segment_type)
+        for pt, smooth, name, kwargs in last_offcurves:
+            pen.addPoint(pt, None, smooth, name, **kwargs)
+        pen.endPath()
+
+    def addComponent(self, baseGlyphName, transformation):
+        assert self.currentPath is None
+        self.pen.addComponent(baseGlyphName, transformation)
+
+
+class Cu2QuMultiPen:
+    """A filter multi-pen to convert cubic bezier curves to quadratic b-splines
+    in a interpolation-compatible manner, using the FontTools SegmentPen protocol.
+
+    Args:
+
+        other_pens: list of SegmentPens used to draw the transformed outlines.
+        max_err: maximum approximation error in font units. For optimal results,
+            if you know the UPEM of the font, we recommend setting this to a
+            value equal, or close to UPEM / 1000.
+        reverse_direction: flip the contours' direction but keep starting point.
+
+    This pen does not follow the normal SegmentPen protocol. Instead, its
+    moveTo/lineTo/qCurveTo/curveTo methods take a list of tuples that are
+    arguments that would normally be passed to a SegmentPen, one item for
+    each of the pens in other_pens.
+    """
+
+    # TODO Simplify like 3e8ebcdce592fe8a59ca4c3a294cc9724351e1ce
+    # Remove start_pts and _add_moveTO
+
+    def __init__(self, other_pens, max_err, reverse_direction=False):
+        if reverse_direction:
+            other_pens = [
+                ReverseContourPen(pen, outputImpliedClosingLine=True)
+                for pen in other_pens
+            ]
+        self.pens = other_pens
+        self.max_err = max_err
+        self.start_pts = None
+        self.current_pts = None
+
+    def _check_contour_is_open(self):
+        if self.current_pts is None:
+            raise AssertionError("moveTo is required")
+
+    def _check_contour_is_closed(self):
+        if self.current_pts is not None:
+            raise AssertionError("closePath or endPath is required")
+
+    def _add_moveTo(self):
+        if self.start_pts is not None:
+            for pt, pen in zip(self.start_pts, self.pens):
+                pen.moveTo(*pt)
+            self.start_pts = None
+
+    def moveTo(self, pts):
+        self._check_contour_is_closed()
+        self.start_pts = self.current_pts = pts
+        self._add_moveTo()
+
+    def lineTo(self, pts):
+        self._check_contour_is_open()
+        self._add_moveTo()
+        for pt, pen in zip(pts, self.pens):
+            pen.lineTo(*pt)
+        self.current_pts = pts
+
+    def qCurveTo(self, pointsList):
+        self._check_contour_is_open()
+        if len(pointsList[0]) == 1:
+            self.lineTo([(points[0],) for points in pointsList])
+            return
+        self._add_moveTo()
+        current_pts = []
+        for points, pen in zip(pointsList, self.pens):
+            pen.qCurveTo(*points)
+            current_pts.append((points[-1],))
+        self.current_pts = current_pts
+
+    def _curves_to_quadratic(self, pointsList):
+        curves = []
+        for current_pt, points in zip(self.current_pts, pointsList):
+            curves.append(current_pt + points)
+        quadratics = curves_to_quadratic(curves, [self.max_err] * len(curves))
+        pointsList = []
+        for quadratic in quadratics:
+            pointsList.append(quadratic[1:])
+        self.qCurveTo(pointsList)
+
+    def curveTo(self, pointsList):
+        self._check_contour_is_open()
+        self._curves_to_quadratic(pointsList)
+
+    def closePath(self):
+        self._check_contour_is_open()
+        if self.start_pts is None:
+            for pen in self.pens:
+                pen.closePath()
+        self.current_pts = self.start_pts = None
+
+    def endPath(self):
+        self._check_contour_is_open()
+        if self.start_pts is None:
+            for pen in self.pens:
+                pen.endPath()
+        self.current_pts = self.start_pts = None
+
+    def addComponent(self, glyphName, transformations):
+        self._check_contour_is_closed()
+        for trans, pen in zip(transformations, self.pens):
+            pen.addComponent(glyphName, trans)

fontTools/pens/explicitClosingLinePen.py

@@ -0,0 +1,101 @@
+from fontTools.pens.filterPen import ContourFilterPen
+
+
+class ExplicitClosingLinePen(ContourFilterPen):
+    """A filter pen that adds an explicit lineTo to the first point of each closed
+    contour if the end point of the last segment is not already the same as the first point.
+    Otherwise, it passes the contour through unchanged.
+
+    >>> from pprint import pprint
+    >>> from fontTools.pens.recordingPen import RecordingPen
+    >>> rec = RecordingPen()
+    >>> pen = ExplicitClosingLinePen(rec)
+    >>> pen.moveTo((0, 0))
+    >>> pen.lineTo((100, 0))
+    >>> pen.lineTo((100, 100))
+    >>> pen.closePath()
+    >>> pprint(rec.value)
+    [('moveTo', ((0, 0),)),
+     ('lineTo', ((100, 0),)),
+     ('lineTo', ((100, 100),)),
+     ('lineTo', ((0, 0),)),
+     ('closePath', ())]
+    >>> rec = RecordingPen()
+    >>> pen = ExplicitClosingLinePen(rec)
+    >>> pen.moveTo((0, 0))
+    >>> pen.lineTo((100, 0))
+    >>> pen.lineTo((100, 100))
+    >>> pen.lineTo((0, 0))
+    >>> pen.closePath()
+    >>> pprint(rec.value)
+    [('moveTo', ((0, 0),)),
+     ('lineTo', ((100, 0),)),
+     ('lineTo', ((100, 100),)),
+     ('lineTo', ((0, 0),)),
+     ('closePath', ())]
+    >>> rec = RecordingPen()
+    >>> pen = ExplicitClosingLinePen(rec)
+    >>> pen.moveTo((0, 0))
+    >>> pen.curveTo((100, 0), (0, 100), (100, 100))
+    >>> pen.closePath()
+    >>> pprint(rec.value)
+    [('moveTo', ((0, 0),)),
+     ('curveTo', ((100, 0), (0, 100), (100, 100))),
+     ('lineTo', ((0, 0),)),
+     ('closePath', ())]
+    >>> rec = RecordingPen()
+    >>> pen = ExplicitClosingLinePen(rec)
+    >>> pen.moveTo((0, 0))
+    >>> pen.curveTo((100, 0), (0, 100), (100, 100))
+    >>> pen.lineTo((0, 0))
+    >>> pen.closePath()
+    >>> pprint(rec.value)
+    [('moveTo', ((0, 0),)),
+     ('curveTo', ((100, 0), (0, 100), (100, 100))),
+     ('lineTo', ((0, 0),)),
+     ('closePath', ())]
+    >>> rec = RecordingPen()
+    >>> pen = ExplicitClosingLinePen(rec)
+    >>> pen.moveTo((0, 0))
+    >>> pen.curveTo((100, 0), (0, 100), (0, 0))
+    >>> pen.closePath()
+    >>> pprint(rec.value)
+    [('moveTo', ((0, 0),)),
+     ('curveTo', ((100, 0), (0, 100), (0, 0))),
+     ('closePath', ())]
+    >>> rec = RecordingPen()
+    >>> pen = ExplicitClosingLinePen(rec)
+    >>> pen.moveTo((0, 0))
+    >>> pen.closePath()
+    >>> pprint(rec.value)
+    [('moveTo', ((0, 0),)), ('closePath', ())]
+    >>> rec = RecordingPen()
+    >>> pen = ExplicitClosingLinePen(rec)
+    >>> pen.closePath()
+    >>> pprint(rec.value)
+    [('closePath', ())]
+    >>> rec = RecordingPen()
+    >>> pen = ExplicitClosingLinePen(rec)
+    >>> pen.moveTo((0, 0))
+    >>> pen.lineTo((100, 0))
+    >>> pen.lineTo((100, 100))
+    >>> pen.endPath()
+    >>> pprint(rec.value)
+    [('moveTo', ((0, 0),)),
+     ('lineTo', ((100, 0),)),
+     ('lineTo', ((100, 100),)),
+     ('endPath', ())]
+    """
+
+    def filterContour(self, contour):
+        if (
+            not contour
+            or contour[0][0] != "moveTo"
+            or contour[-1][0] != "closePath"
+            or len(contour) < 3
+        ):
+            return
+        movePt = contour[0][1][0]
+        lastSeg = contour[-2][1]
+        if lastSeg and movePt != lastSeg[-1]:
+            contour[-1:] = [("lineTo", (movePt,)), ("closePath", ())]

fontTools/pens/filterPen.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+from fontTools.pens.basePen import AbstractPen, DecomposingPen
+from fontTools.pens.pointPen import AbstractPointPen, DecomposingPointPen
+from fontTools.pens.recordingPen import RecordingPen
+
+
+class _PassThruComponentsMixin(object):
+    def addComponent(self, glyphName, transformation, **kwargs):
+        self._outPen.addComponent(glyphName, transformation, **kwargs)
+
+
+class FilterPen(_PassThruComponentsMixin, AbstractPen):
+    """Base class for pens that apply some transformation to the coordinates
+    they receive and pass them to another pen.
+
+    You can override any of its methods. The default implementation does
+    nothing, but passes the commands unmodified to the other pen.
+
+    >>> from fontTools.pens.recordingPen import RecordingPen
+    >>> rec = RecordingPen()
+    >>> pen = FilterPen(rec)
+    >>> v = iter(rec.value)
+
+    >>> pen.moveTo((0, 0))
+    >>> next(v)
+    ('moveTo', ((0, 0),))
+
+    >>> pen.lineTo((1, 1))
+    >>> next(v)
+    ('lineTo', ((1, 1),))
+
+    >>> pen.curveTo((2, 2), (3, 3), (4, 4))
+    >>> next(v)
+    ('curveTo', ((2, 2), (3, 3), (4, 4)))
+
+    >>> pen.qCurveTo((5, 5), (6, 6), (7, 7), (8, 8))
+    >>> next(v)
+    ('qCurveTo', ((5, 5), (6, 6), (7, 7), (8, 8)))
+
+    >>> pen.closePath()
+    >>> next(v)
+    ('closePath', ())
+
+    >>> pen.moveTo((9, 9))
+    >>> next(v)
+    ('moveTo', ((9, 9),))
+
+    >>> pen.endPath()
+    >>> next(v)
+    ('endPath', ())
+
+    >>> pen.addComponent('foo', (1, 0, 0, 1, 0, 0))
+    >>> next(v)
+    ('addComponent', ('foo', (1, 0, 0, 1, 0, 0)))
+    """
+
+    def __init__(self, outPen):
+        self._outPen = outPen
+        self.current_pt = None
+
+    def moveTo(self, pt):
+        self._outPen.moveTo(pt)
+        self.current_pt = pt
+
+    def lineTo(self, pt):
+        self._outPen.lineTo(pt)
+        self.current_pt = pt
+
+    def curveTo(self, *points):
+        self._outPen.curveTo(*points)
+        self.current_pt = points[-1]
+
+    def qCurveTo(self, *points):
+        self._outPen.qCurveTo(*points)
+        self.current_pt = points[-1]
+
+    def closePath(self):
+        self._outPen.closePath()
+        self.current_pt = None
+
+    def endPath(self):
+        self._outPen.endPath()
+        self.current_pt = None
+
+
+class ContourFilterPen(_PassThruComponentsMixin, RecordingPen):
+    """A "buffered" filter pen that accumulates contour data, passes
+    it through a ``filterContour`` method when the contour is closed or ended,
+    and finally draws the result with the output pen.
+
+    Components are passed through unchanged.
+    """
+
+    def __init__(self, outPen):
+        super(ContourFilterPen, self).__init__()
+        self._outPen = outPen
+
+    def closePath(self):
+        super(ContourFilterPen, self).closePath()
+        self._flushContour()
+
+    def endPath(self):
+        super(ContourFilterPen, self).endPath()
+        self._flushContour()
+
+    def _flushContour(self):
+        result = self.filterContour(self.value)
+        if result is not None:
+            self.value = result
+        self.replay(self._outPen)
+        self.value = []
+
+    def filterContour(self, contour):
+        """Subclasses must override this to perform the filtering.
+
+        The contour is a list of pen (operator, operands) tuples.
+        Operators are strings corresponding to the AbstractPen methods:
+        "moveTo", "lineTo", "curveTo", "qCurveTo", "closePath" and
+        "endPath". The operands are the positional arguments that are
+        passed to each method.
+
+        If the method doesn't return a value (i.e. returns None), it's
+        assumed that the argument was modified in-place.
+        Otherwise, the return value is drawn with the output pen.
+        """
+        return  # or return contour
+
+
+class FilterPointPen(_PassThruComponentsMixin, AbstractPointPen):
+    """Baseclass for point pens that apply some transformation to the
+    coordinates they receive and pass them to another point pen.
+
+    You can override any of its methods. The default implementation does
+    nothing, but passes the commands unmodified to the other pen.
+
+    >>> from fontTools.pens.recordingPen import RecordingPointPen
+    >>> rec = RecordingPointPen()
+    >>> pen = FilterPointPen(rec)
+    >>> v = iter(rec.value)
+    >>> pen.beginPath(identifier="abc")
+    >>> next(v)
+    ('beginPath', (), {'identifier': 'abc'})
+    >>> pen.addPoint((1, 2), "line", False)
+    >>> next(v)
+    ('addPoint', ((1, 2), 'line', False, None), {})
+    >>> pen.addComponent("a", (2, 0, 0, 2, 10, -10), identifier="0001")
+    >>> next(v)
+    ('addComponent', ('a', (2, 0, 0, 2, 10, -10)), {'identifier': '0001'})
+    >>> pen.endPath()
+    >>> next(v)
+    ('endPath', (), {})
+    """
+
+    def __init__(self, outPen):
+        self._outPen = outPen
+
+    def beginPath(self, **kwargs):
+        self._outPen.beginPath(**kwargs)
+
+    def endPath(self):
+        self._outPen.endPath()
+
+    def addPoint(self, pt, segmentType=None, smooth=False, name=None, **kwargs):
+        self._outPen.addPoint(pt, segmentType, smooth, name, **kwargs)
+
+
+class _DecomposingFilterPenMixin:
+    """Mixin class that decomposes components as regular contours.
+
+    Shared by both DecomposingFilterPen and DecomposingFilterPointPen.
+
+    Takes two required parameters, another (segment or point) pen 'outPen' to draw
+    with, and a 'glyphSet' dict of drawable glyph objects to draw components from.
+
+    The 'skipMissingComponents' and 'reverseFlipped' optional arguments work the
+    same as in the DecomposingPen/DecomposingPointPen. Both are False by default.
+
+    In addition, the decomposing filter pens also take the following two options:
+
+    'include' is an optional set of component base glyph names to consider for
+    decomposition; the default include=None means decompose all components no matter
+    the base glyph name).
+
+    'decomposeNested' (bool) controls whether to recurse decomposition into nested
+    components of components (this only matters when 'include' was also provided);
+    if False, only decompose top-level components included in the set, but not
+    also their children.
+    """
+
+    # raises MissingComponentError if base glyph is not found in glyphSet
+    skipMissingComponents = False
+
+    def __init__(
+        self,
+        outPen,
+        glyphSet,
+        skipMissingComponents=None,
+        reverseFlipped=False,
+        include: set[str] | None = None,
+        decomposeNested: bool = True,
+    ):
+        super().__init__(
+            outPen=outPen,
+            glyphSet=glyphSet,
+            skipMissingComponents=skipMissingComponents,
+            reverseFlipped=reverseFlipped,
+        )
+        self.include = include
+        self.decomposeNested = decomposeNested
+
+    def addComponent(self, baseGlyphName, transformation, **kwargs):
+        # only decompose the component if it's included in the set
+        if self.include is None or baseGlyphName in self.include:
+            # if we're decomposing nested components, temporarily set include to None
+            include_bak = self.include
+            if self.decomposeNested and self.include:
+                self.include = None
+            try:
+                super().addComponent(baseGlyphName, transformation, **kwargs)
+            finally:
+                if self.include != include_bak:
+                    self.include = include_bak
+        else:
+            _PassThruComponentsMixin.addComponent(
+                self, baseGlyphName, transformation, **kwargs
+            )
+
+
+class DecomposingFilterPen(_DecomposingFilterPenMixin, DecomposingPen, FilterPen):
+    """Filter pen that draws components as regular contours."""
+
+    pass
+
+
+class DecomposingFilterPointPen(
+    _DecomposingFilterPenMixin, DecomposingPointPen, FilterPointPen
+):
+    """Filter point pen that draws components as regular contours."""
+
+    pass