fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/pens/ttGlyphPen.py

@@ -0,0 +1,335 @@
+from array import array
+from typing import Any, Callable, Dict, Optional, Tuple
+from fontTools.misc.fixedTools import MAX_F2DOT14, floatToFixedToFloat
+from fontTools.misc.loggingTools import LogMixin
+from fontTools.pens.pointPen import AbstractPointPen
+from fontTools.misc.roundTools import otRound
+from fontTools.pens.basePen import LoggingPen, PenError
+from fontTools.pens.transformPen import TransformPen, TransformPointPen
+from fontTools.ttLib.tables import ttProgram
+from fontTools.ttLib.tables._g_l_y_f import flagOnCurve, flagCubic
+from fontTools.ttLib.tables._g_l_y_f import Glyph
+from fontTools.ttLib.tables._g_l_y_f import GlyphComponent
+from fontTools.ttLib.tables._g_l_y_f import GlyphCoordinates
+from fontTools.ttLib.tables._g_l_y_f import dropImpliedOnCurvePoints
+import math
+
+
+__all__ = ["TTGlyphPen", "TTGlyphPointPen"]
+
+
+class _TTGlyphBasePen:
+    def __init__(
+        self,
+        glyphSet: Optional[Dict[str, Any]],
+        handleOverflowingTransforms: bool = True,
+    ) -> None:
+        """
+        Construct a new pen.
+
+        Args:
+            glyphSet (Dict[str, Any]): A glyphset object, used to resolve components.
+            handleOverflowingTransforms (bool): See below.
+
+        If ``handleOverflowingTransforms`` is True, the components' transform values
+        are checked that they don't overflow the limits of a F2Dot14 number:
+        -2.0 <= v < +2.0. If any transform value exceeds these, the composite
+        glyph is decomposed.
+
+        An exception to this rule is done for values that are very close to +2.0
+        (both for consistency with the -2.0 case, and for the relative frequency
+        these occur in real fonts). When almost +2.0 values occur (and all other
+        values are within the range -2.0 <= x <= +2.0), they are clamped to the
+        maximum positive value that can still be encoded as an F2Dot14: i.e.
+        1.99993896484375.
+
+        If False, no check is done and all components are translated unmodified
+        into the glyf table, followed by an inevitable ``struct.error`` once an
+        attempt is made to compile them.
+
+        If both contours and components are present in a glyph, the components
+        are decomposed.
+        """
+        self.glyphSet = glyphSet
+        self.handleOverflowingTransforms = handleOverflowingTransforms
+        self.init()
+
+    def _decompose(
+        self,
+        glyphName: str,
+        transformation: Tuple[float, float, float, float, float, float],
+    ):
+        tpen = self.transformPen(self, transformation)
+        getattr(self.glyphSet[glyphName], self.drawMethod)(tpen)
+
+    def _isClosed(self):
+        """
+        Check if the current path is closed.
+        """
+        raise NotImplementedError
+
+    def init(self) -> None:
+        self.points = []
+        self.endPts = []
+        self.types = []
+        self.components = []
+
+    def addComponent(
+        self,
+        baseGlyphName: str,
+        transformation: Tuple[float, float, float, float, float, float],
+        identifier: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Add a sub glyph.
+        """
+        self.components.append((baseGlyphName, transformation))
+
+    def _buildComponents(self, componentFlags):
+        if self.handleOverflowingTransforms:
+            # we can't encode transform values > 2 or < -2 in F2Dot14,
+            # so we must decompose the glyph if any transform exceeds these
+            overflowing = any(
+                s > 2 or s < -2
+                for (glyphName, transformation) in self.components
+                for s in transformation[:4]
+            )
+        components = []
+        for glyphName, transformation in self.components:
+            if glyphName not in self.glyphSet:
+                self.log.warning(f"skipped non-existing component '{glyphName}'")
+                continue
+            if self.points or (self.handleOverflowingTransforms and overflowing):
+                # can't have both coordinates and components, so decompose
+                self._decompose(glyphName, transformation)
+                continue
+
+            component = GlyphComponent()
+            component.glyphName = glyphName
+            component.x, component.y = (otRound(v) for v in transformation[4:])
+            # quantize floats to F2Dot14 so we get same values as when decompiled
+            # from a binary glyf table
+            transformation = tuple(
+                floatToFixedToFloat(v, 14) for v in transformation[:4]
+            )
+            if transformation != (1, 0, 0, 1):
+                if self.handleOverflowingTransforms and any(
+                    MAX_F2DOT14 < s <= 2 for s in transformation
+                ):
+                    # clamp values ~= +2.0 so we can keep the component
+                    transformation = tuple(
+                        MAX_F2DOT14 if MAX_F2DOT14 < s <= 2 else s
+                        for s in transformation
+                    )
+                component.transform = (transformation[:2], transformation[2:])
+            component.flags = componentFlags
+            components.append(component)
+        return components
+
+    def glyph(
+        self,
+        componentFlags: int = 0x04,
+        dropImpliedOnCurves: bool = False,
+        *,
+        round: Callable[[float], int] = otRound,
+    ) -> Glyph:
+        """
+        Returns a :py:class:`~._g_l_y_f.Glyph` object representing the glyph.
+
+        Args:
+            componentFlags: Flags to use for component glyphs. (default: 0x04)
+
+            dropImpliedOnCurves: Whether to remove implied-oncurve points. (default: False)
+        """
+        if not self._isClosed():
+            raise PenError("Didn't close last contour.")
+        components = self._buildComponents(componentFlags)
+
+        glyph = Glyph()
+        glyph.coordinates = GlyphCoordinates(self.points)
+        glyph.endPtsOfContours = self.endPts
+        glyph.flags = array("B", self.types)
+        self.init()
+
+        if components:
+            # If both components and contours were present, they have by now
+            # been decomposed by _buildComponents.
+            glyph.components = components
+            glyph.numberOfContours = -1
+        else:
+            glyph.numberOfContours = len(glyph.endPtsOfContours)
+            glyph.program = ttProgram.Program()
+            glyph.program.fromBytecode(b"")
+            if dropImpliedOnCurves:
+                dropImpliedOnCurvePoints(glyph)
+            glyph.coordinates.toInt(round=round)
+
+        return glyph
+
+
+class TTGlyphPen(_TTGlyphBasePen, LoggingPen):
+    """
+    Pen used for drawing to a TrueType glyph.
+
+    This pen can be used to construct or modify glyphs in a TrueType format
+    font. After using the pen to draw, use the ``.glyph()`` method to retrieve
+    a :py:class:`~._g_l_y_f.Glyph` object representing the glyph.
+    """
+
+    drawMethod = "draw"
+    transformPen = TransformPen
+
+    def __init__(
+        self,
+        glyphSet: Optional[Dict[str, Any]] = None,
+        handleOverflowingTransforms: bool = True,
+        outputImpliedClosingLine: bool = False,
+    ) -> None:
+        super().__init__(glyphSet, handleOverflowingTransforms)
+        self.outputImpliedClosingLine = outputImpliedClosingLine
+
+    def _addPoint(self, pt: Tuple[float, float], tp: int) -> None:
+        self.points.append(pt)
+        self.types.append(tp)
+
+    def _popPoint(self) -> None:
+        self.points.pop()
+        self.types.pop()
+
+    def _isClosed(self) -> bool:
+        return (not self.points) or (
+            self.endPts and self.endPts[-1] == len(self.points) - 1
+        )
+
+    def lineTo(self, pt: Tuple[float, float]) -> None:
+        self._addPoint(pt, flagOnCurve)
+
+    def moveTo(self, pt: Tuple[float, float]) -> None:
+        if not self._isClosed():
+            raise PenError('"move"-type point must begin a new contour.')
+        self._addPoint(pt, flagOnCurve)
+
+    def curveTo(self, *points) -> None:
+        assert len(points) % 2 == 1
+        for pt in points[:-1]:
+            self._addPoint(pt, flagCubic)
+
+        # last point is None if there are no on-curve points
+        if points[-1] is not None:
+            self._addPoint(points[-1], 1)
+
+    def qCurveTo(self, *points) -> None:
+        assert len(points) >= 1
+        for pt in points[:-1]:
+            self._addPoint(pt, 0)
+
+        # last point is None if there are no on-curve points
+        if points[-1] is not None:
+            self._addPoint(points[-1], 1)
+
+    def closePath(self) -> None:
+        endPt = len(self.points) - 1
+
+        # ignore anchors (one-point paths)
+        if endPt == 0 or (self.endPts and endPt == self.endPts[-1] + 1):
+            self._popPoint()
+            return
+
+        if not self.outputImpliedClosingLine:
+            # if first and last point on this path are the same, remove last
+            startPt = 0
+            if self.endPts:
+                startPt = self.endPts[-1] + 1
+            if self.points[startPt] == self.points[endPt]:
+                self._popPoint()
+                endPt -= 1
+
+        self.endPts.append(endPt)
+
+    def endPath(self) -> None:
+        # TrueType contours are always "closed"
+        self.closePath()
+
+
+class TTGlyphPointPen(_TTGlyphBasePen, LogMixin, AbstractPointPen):
+    """
+    Point pen used for drawing to a TrueType glyph.
+
+    This pen can be used to construct or modify glyphs in a TrueType format
+    font. After using the pen to draw, use the ``.glyph()`` method to retrieve
+    a :py:class:`~._g_l_y_f.Glyph` object representing the glyph.
+    """
+
+    drawMethod = "drawPoints"
+    transformPen = TransformPointPen
+
+    def init(self) -> None:
+        super().init()
+        self._currentContourStartIndex = None
+
+    def _isClosed(self) -> bool:
+        return self._currentContourStartIndex is None
+
+    def beginPath(self, identifier: Optional[str] = None, **kwargs: Any) -> None:
+        """
+        Start a new sub path.
+        """
+        if not self._isClosed():
+            raise PenError("Didn't close previous contour.")
+        self._currentContourStartIndex = len(self.points)
+
+    def endPath(self) -> None:
+        """
+        End the current sub path.
+        """
+        # TrueType contours are always "closed"
+        if self._isClosed():
+            raise PenError("Contour is already closed.")
+        if self._currentContourStartIndex == len(self.points):
+            # ignore empty contours
+            self._currentContourStartIndex = None
+            return
+
+        contourStart = self.endPts[-1] + 1 if self.endPts else 0
+        self.endPts.append(len(self.points) - 1)
+        self._currentContourStartIndex = None
+
+        # Resolve types for any cubic segments
+        flags = self.types
+        for i in range(contourStart, len(flags)):
+            if flags[i] == "curve":
+                j = i - 1
+                if j < contourStart:
+                    j = len(flags) - 1
+                while flags[j] == 0:
+                    flags[j] = flagCubic
+                    j -= 1
+                flags[i] = flagOnCurve
+
+    def addPoint(
+        self,
+        pt: Tuple[float, float],
+        segmentType: Optional[str] = None,
+        smooth: bool = False,
+        name: Optional[str] = None,
+        identifier: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Add a point to the current sub path.
+        """
+        if self._isClosed():
+            raise PenError("Can't add a point to a closed contour.")
+        if segmentType is None:
+            self.types.append(0)
+        elif segmentType in ("line", "move"):
+            self.types.append(flagOnCurve)
+        elif segmentType == "qcurve":
+            self.types.append(flagOnCurve)
+        elif segmentType == "curve":
+            self.types.append("curve")
+        else:
+            raise AssertionError(segmentType)
+
+        self.points.append(pt)

fontTools/pens/wxPen.py

@@ -0,0 +1,29 @@
+from fontTools.pens.basePen import BasePen
+
+
+__all__ = ["WxPen"]
+
+
+class WxPen(BasePen):
+    def __init__(self, glyphSet, path=None):
+        BasePen.__init__(self, glyphSet)
+        if path is None:
+            import wx
+
+            path = wx.GraphicsRenderer.GetDefaultRenderer().CreatePath()
+        self.path = path
+
+    def _moveTo(self, p):
+        self.path.MoveToPoint(*p)
+
+    def _lineTo(self, p):
+        self.path.AddLineToPoint(*p)
+
+    def _curveToOne(self, p1, p2, p3):
+        self.path.AddCurveToPoint(*p1 + p2 + p3)
+
+    def _qCurveToOne(self, p1, p2):
+        self.path.AddQuadCurveToPoint(*p1 + p2)
+
+    def _closePath(self):
+        self.path.CloseSubpath()

fontTools/qu2cu/__init__.py

@@ -0,0 +1,15 @@
+# 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.
+
+from .qu2cu import *

fontTools/qu2cu/__main__.py

@@ -0,0 +1,7 @@
+import sys
+
+from .cli import _main as main
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fontTools/qu2cu/benchmark.py

@@ -0,0 +1,56 @@
+"""Benchmark the qu2cu algorithm performance."""
+
+from .qu2cu import *
+from fontTools.cu2qu import curve_to_quadratic
+import random
+import timeit
+
+MAX_ERR = 0.5
+NUM_CURVES = 5
+
+
+def generate_curves(n):
+    points = [
+        tuple(float(random.randint(0, 2048)) for coord in range(2))
+        for point in range(1 + 3 * n)
+    ]
+    curves = []
+    for i in range(n):
+        curves.append(tuple(points[i * 3 : i * 3 + 4]))
+    return curves
+
+
+def setup_quadratic_to_curves():
+    curves = generate_curves(NUM_CURVES)
+    quadratics = [curve_to_quadratic(curve, MAX_ERR) for curve in curves]
+    return quadratics, MAX_ERR
+
+
+def run_benchmark(module, function, setup_suffix="", repeat=25, number=1):
+    setup_func = "setup_" + function
+    if setup_suffix:
+        print("%s with %s:" % (function, setup_suffix), end="")
+        setup_func += "_" + setup_suffix
+    else:
+        print("%s:" % function, end="")
+
+    def wrapper(function, setup_func):
+        function = globals()[function]
+        setup_func = globals()[setup_func]
+
+        def wrapped():
+            return function(*setup_func())
+
+        return wrapped
+
+    results = timeit.repeat(wrapper(function, setup_func), repeat=repeat, number=number)
+    print("\t%5.1fus" % (min(results) * 1000000.0 / number))
+
+
+def main():
+    run_benchmark("qu2cu", "quadratic_to_curves")
+
+
+if __name__ == "__main__":
+    random.seed(1)
+    main()

fontTools/qu2cu/cli.py

@@ -0,0 +1,125 @@
+import os
+import argparse
+import logging
+from fontTools.misc.cliTools import makeOutputFileName
+from fontTools.ttLib import TTFont
+from fontTools.pens.qu2cuPen import Qu2CuPen
+from fontTools.pens.ttGlyphPen import TTGlyphPen
+import fontTools
+
+
+logger = logging.getLogger("fontTools.qu2cu")
+
+
+def _font_to_cubic(input_path, output_path=None, **kwargs):
+    font = TTFont(input_path)
+    logger.info("Converting curves for %s", input_path)
+
+    stats = {} if kwargs["dump_stats"] else None
+    qu2cu_kwargs = {
+        "stats": stats,
+        "max_err": kwargs["max_err_em"] * font["head"].unitsPerEm,
+        "all_cubic": kwargs["all_cubic"],
+    }
+
+    assert "gvar" not in font, "Cannot convert variable font"
+    glyphSet = font.getGlyphSet()
+    glyphOrder = font.getGlyphOrder()
+    glyf = font["glyf"]
+    for glyphName in glyphOrder:
+        glyph = glyphSet[glyphName]
+        ttpen = TTGlyphPen(glyphSet)
+        pen = Qu2CuPen(ttpen, **qu2cu_kwargs)
+        glyph.draw(pen)
+        glyf[glyphName] = ttpen.glyph(dropImpliedOnCurves=True)
+
+    font["head"].glyphDataFormat = 1
+
+    if kwargs["dump_stats"]:
+        logger.info("Stats: %s", stats)
+
+    logger.info("Saving %s", output_path)
+    font.save(output_path)
+
+
+def _main(args=None):
+    """Convert an OpenType font from quadratic to cubic curves"""
+    parser = argparse.ArgumentParser(prog="qu2cu")
+    parser.add_argument("--version", action="version", version=fontTools.__version__)
+    parser.add_argument(
+        "infiles",
+        nargs="+",
+        metavar="INPUT",
+        help="one or more input TTF source file(s).",
+    )
+    parser.add_argument("-v", "--verbose", action="count", default=0)
+    parser.add_argument(
+        "-e",
+        "--conversion-error",
+        type=float,
+        metavar="ERROR",
+        default=0.001,
+        help="maxiumum approximation error measured in EM (default: 0.001)",
+    )
+    parser.add_argument(
+        "-c",
+        "--all-cubic",
+        default=False,
+        action="store_true",
+        help="whether to only use cubic curves",
+    )
+
+    output_parser = parser.add_mutually_exclusive_group()
+    output_parser.add_argument(
+        "-o",
+        "--output-file",
+        default=None,
+        metavar="OUTPUT",
+        help=("output filename for the converted TTF."),
+    )
+    output_parser.add_argument(
+        "-d",
+        "--output-dir",
+        default=None,
+        metavar="DIRECTORY",
+        help="output directory where to save converted TTFs",
+    )
+
+    options = parser.parse_args(args)
+
+    if not options.verbose:
+        level = "WARNING"
+    elif options.verbose == 1:
+        level = "INFO"
+    else:
+        level = "DEBUG"
+    logging.basicConfig(level=level)
+
+    if len(options.infiles) > 1 and options.output_file:
+        parser.error("-o/--output-file can't be used with multile inputs")
+
+    if options.output_dir:
+        output_dir = options.output_dir
+        if not os.path.exists(output_dir):
+            os.mkdir(output_dir)
+        elif not os.path.isdir(output_dir):
+            parser.error("'%s' is not a directory" % output_dir)
+        output_paths = [
+            os.path.join(output_dir, os.path.basename(p)) for p in options.infiles
+        ]
+    elif options.output_file:
+        output_paths = [options.output_file]
+    else:
+        output_paths = [
+            makeOutputFileName(p, overWrite=True, suffix=".cubic")
+            for p in options.infiles
+        ]
+
+    kwargs = dict(
+        dump_stats=options.verbose > 0,
+        max_err_em=options.conversion_error,
+        all_cubic=options.all_cubic,
+    )
+
+    for input_path, output_path in zip(options.infiles, output_paths):
+        _font_to_cubic(input_path, output_path, **kwargs)