Spaces:
Running
Running
| # 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) | |