up follow livre
This commit is contained in:
Tykayn
tykayn
parent
70a5c3465c
commit
cffb31c1ef
12198 changed files with 2562132 additions and 35 deletions
325
venv/lib/python3.13/site-packages/fontTools/pens/cu2quPen.py
Normal file
325
venv/lib/python3.13/site-packages/fontTools/pens/cu2quPen.py
Normal file
|
|
@ -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)
|
||||
Loading…
Add table
Add a link
Reference in a new issue