129 lines
4.5 KiB
Python
129 lines
4.5 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""Calculate the perimeter of a glyph."""
|
|
|
|
from __future__ import print_function, division, absolute_import
|
|
from fontTools.misc.py23 import *
|
|
from fontTools.pens.basePen import BasePen
|
|
from fontTools.misc.bezierTools import splitQuadraticAtT, splitCubicAtT
|
|
import math
|
|
|
|
|
|
def _distance(p0, p1):
|
|
return math.hypot(p0[0] - p1[0], p0[1] - p1[1])
|
|
def _dot(v1, v2):
|
|
return (v1 * v2.conjugate()).real
|
|
def _intSecAtan(x):
|
|
# In : sympy.integrate(sp.sec(sp.atan(x)))
|
|
# Out: x*sqrt(x**2 + 1)/2 + asinh(x)/2
|
|
return x * math.sqrt(x**2 + 1)/2 + math.asinh(x)/2
|
|
|
|
def _split_cubic_into_two(p0, p1, p2, p3):
|
|
mid = (p0 + 3 * (p1 + p2) + p3) * .125
|
|
deriv3 = (p3 + p2 - p1 - p0) * .125
|
|
return ((p0, (p0 + p1) * .5, mid - deriv3, mid),
|
|
(mid, mid + deriv3, (p2 + p3) * .5, p3))
|
|
|
|
class PerimeterPen(BasePen):
|
|
|
|
def __init__(self, glyphset=None, tolerance=0.005):
|
|
BasePen.__init__(self, glyphset)
|
|
self.value = 0
|
|
self._mult = 1.+1.5*tolerance # The 1.5 is a empirical hack; no math
|
|
|
|
# Choose which algorithm to use for quadratic and for cubic.
|
|
# Lobatto is faster but has fixed error characteristic with no strong
|
|
# error bound. The cutoff points are derived empirically.
|
|
self._addCubic = self._addCubicLobatto if tolerance >= 0.0015 else self._addCubicRecursive
|
|
self._addQuadratic = self._addQuadraticLobatto if tolerance >= 0.00075 else self._addQuadraticExact
|
|
|
|
def _moveTo(self, p0):
|
|
self.__startPoint = p0
|
|
|
|
def _lineTo(self, p1):
|
|
p0 = self._getCurrentPoint()
|
|
self.value += _distance(p0, p1)
|
|
|
|
def _addQuadraticExact(self, c0, c1, c2):
|
|
# Analytical solution to the length of a quadratic bezier.
|
|
# I'll explain how I arrived at this later.
|
|
d0 = c1 - c0
|
|
d1 = c2 - c1
|
|
d = d1 - d0
|
|
n = d * 1j
|
|
scale = abs(n)
|
|
if scale == 0.:
|
|
self.value += abs(c2-c0)
|
|
return
|
|
origDist = _dot(n,d0)
|
|
if origDist == 0.:
|
|
if _dot(d0,d1) >= 0:
|
|
self.value += abs(c2-c0)
|
|
return
|
|
assert 0 # TODO handle cusps
|
|
x0 = _dot(d,d0) / origDist
|
|
x1 = _dot(d,d1) / origDist
|
|
Len = abs(2 * (_intSecAtan(x1) - _intSecAtan(x0)) * origDist / (scale * (x1 - x0)))
|
|
self.value += Len
|
|
|
|
def _addQuadraticLobatto(self, c0, c1, c2):
|
|
# Approximate length of quadratic Bezier curve using Lobatto quadrature
|
|
# with n=4 points: endpoints and at t=.5±sqrt(1/5)/2
|
|
#
|
|
# This, essentially, approximates the length-of-derivative function
|
|
# to be integrated with the best-matching fifth-degree polynomial
|
|
# approximation of it.
|
|
#
|
|
# https://en.wikipedia.org/wiki/Gaussian_quadrature#Gauss.E2.80.93Lobatto_rules
|
|
|
|
# abs(BezierCurveC[3].diff(t).subs({t:T})) for T in (0, .5-(1/5)**.5/2, .5, .5+(1/5)**.5/2, 1),
|
|
# weighted 1/20, 49/180, 32/90, 49/180, 1/20 respectively.
|
|
v0 = abs(c1-c0)*0.166666666666667
|
|
v1 = abs(-0.603005664791649*c0 + 0.372677996249965*c1 + 0.230327668541684*c2)
|
|
v2 = abs(-0.230327668541684*c0 - 0.372677996249965*c1 + 0.603005664791649*c2)
|
|
v3 = abs(c2-c1)*0.166666666666667
|
|
|
|
self.value += v0 + v1 + v2 + v3
|
|
|
|
def _qCurveToOne(self, p1, p2):
|
|
p0 = self._getCurrentPoint()
|
|
self._addQuadratic(complex(*p0), complex(*p1), complex(*p2))
|
|
|
|
def _addCubicRecursive(self, p0, p1, p2, p3):
|
|
arch = abs(p0-p3)
|
|
box = abs(p0-p1) + abs(p1-p2) + abs(p2-p3)
|
|
if arch * self._mult >= box:
|
|
self.value += (arch + box) * .5
|
|
else:
|
|
one,two = _split_cubic_into_two(p0,p1,p2,p3)
|
|
self._addCubicRecursive(*one)
|
|
self._addCubicRecursive(*two)
|
|
|
|
def _addCubicLobatto(self, c0, c1, c2, c3):
|
|
# Approximate length of cubic Bezier curve using Lobatto quadrature
|
|
# with n=5 points: endpoints, midpoint, and at t=.5±sqrt(3/7)/2
|
|
#
|
|
# This, essentially, approximates the length-of-derivative function
|
|
# to be integrated with the best-matching seventh-degree polynomial
|
|
# approximation of it.
|
|
#
|
|
# https://en.wikipedia.org/wiki/Gaussian_quadrature#Gauss.E2.80.93Lobatto_rules
|
|
|
|
# abs(BezierCurveC[3].diff(t).subs({t:T})) for T in (0, .5-(3/7)**.5/2, .5, .5+(3/7)**.5/2, 1),
|
|
# weighted 1/20, 49/180, 32/90, 49/180, 1/20 respectively.
|
|
v0 = abs(c1-c0)*.15
|
|
v1 = abs(-0.558983582205757*c0 + 0.325650248872424*c1 + 0.208983582205757*c2 + 0.024349751127576*c3)
|
|
v2 = abs(c3-c0+c2-c1)*0.26666666666666666
|
|
v3 = abs(-0.024349751127576*c0 - 0.208983582205757*c1 - 0.325650248872424*c2 + 0.558983582205757*c3)
|
|
v4 = abs(c3-c2)*.15
|
|
|
|
self.value += v0 + v1 + v2 + v3 + v4
|
|
|
|
def _curveToOne(self, p1, p2, p3):
|
|
p0 = self._getCurrentPoint()
|
|
self._addCubic(complex(*p0), complex(*p1), complex(*p2), complex(*p3))
|
|
|
|
def _closePath(self):
|
|
p0 = self._getCurrentPoint()
|
|
if p0 != self.__startPoint:
|
|
self.value += _distance(p0, self.__startPoint)
|