ai-content-maker/.venv/Lib/site-packages/fontTools/varLib/avarPlanner.py

1005 lines
27 KiB
Python
Raw Normal View History

2024-05-03 04:18:51 +03:00
from fontTools.ttLib import newTable
from fontTools.ttLib.tables._f_v_a_r import Axis as fvarAxis
from fontTools.pens.areaPen import AreaPen
from fontTools.pens.basePen import NullPen
from fontTools.pens.statisticsPen import StatisticsPen
from fontTools.varLib.models import piecewiseLinearMap, normalizeValue
from fontTools.misc.cliTools import makeOutputFileName
import math
import logging
from pprint import pformat
__all__ = [
"planWeightAxis",
"planWidthAxis",
"planSlantAxis",
"planOpticalSizeAxis",
"planAxis",
"sanitizeWeight",
"sanitizeWidth",
"sanitizeSlant",
"measureWeight",
"measureWidth",
"measureSlant",
"normalizeLinear",
"normalizeLog",
"normalizeDegrees",
"interpolateLinear",
"interpolateLog",
"processAxis",
"makeDesignspaceSnippet",
"addEmptyAvar",
"main",
]
log = logging.getLogger("fontTools.varLib.avarPlanner")
WEIGHTS = [
50,
100,
150,
200,
250,
300,
350,
400,
450,
500,
550,
600,
650,
700,
750,
800,
850,
900,
950,
]
WIDTHS = [
25.0,
37.5,
50.0,
62.5,
75.0,
87.5,
100.0,
112.5,
125.0,
137.5,
150.0,
162.5,
175.0,
187.5,
200.0,
]
SLANTS = list(math.degrees(math.atan(d / 20.0)) for d in range(-20, 21))
SIZES = [
5,
6,
7,
8,
9,
10,
11,
12,
14,
18,
24,
30,
36,
48,
60,
72,
96,
120,
144,
192,
240,
288,
]
SAMPLES = 8
def normalizeLinear(value, rangeMin, rangeMax):
"""Linearly normalize value in [rangeMin, rangeMax] to [0, 1], with extrapolation."""
return (value - rangeMin) / (rangeMax - rangeMin)
def interpolateLinear(t, a, b):
"""Linear interpolation between a and b, with t typically in [0, 1]."""
return a + t * (b - a)
def normalizeLog(value, rangeMin, rangeMax):
"""Logarithmically normalize value in [rangeMin, rangeMax] to [0, 1], with extrapolation."""
logMin = math.log(rangeMin)
logMax = math.log(rangeMax)
return (math.log(value) - logMin) / (logMax - logMin)
def interpolateLog(t, a, b):
"""Logarithmic interpolation between a and b, with t typically in [0, 1]."""
logA = math.log(a)
logB = math.log(b)
return math.exp(logA + t * (logB - logA))
def normalizeDegrees(value, rangeMin, rangeMax):
"""Angularly normalize value in [rangeMin, rangeMax] to [0, 1], with extrapolation."""
tanMin = math.tan(math.radians(rangeMin))
tanMax = math.tan(math.radians(rangeMax))
return (math.tan(math.radians(value)) - tanMin) / (tanMax - tanMin)
def measureWeight(glyphset, glyphs=None):
"""Measure the perceptual average weight of the given glyphs."""
if isinstance(glyphs, dict):
frequencies = glyphs
else:
frequencies = {g: 1 for g in glyphs}
wght_sum = wdth_sum = 0
for glyph_name in glyphs:
if frequencies is not None:
frequency = frequencies.get(glyph_name, 0)
if frequency == 0:
continue
else:
frequency = 1
glyph = glyphset[glyph_name]
pen = AreaPen(glyphset=glyphset)
glyph.draw(pen)
mult = glyph.width * frequency
wght_sum += mult * abs(pen.value)
wdth_sum += mult
return wght_sum / wdth_sum
def measureWidth(glyphset, glyphs=None):
"""Measure the average width of the given glyphs."""
if isinstance(glyphs, dict):
frequencies = glyphs
else:
frequencies = {g: 1 for g in glyphs}
wdth_sum = 0
freq_sum = 0
for glyph_name in glyphs:
if frequencies is not None:
frequency = frequencies.get(glyph_name, 0)
if frequency == 0:
continue
else:
frequency = 1
glyph = glyphset[glyph_name]
pen = NullPen()
glyph.draw(pen)
wdth_sum += glyph.width * frequency
freq_sum += frequency
return wdth_sum / freq_sum
def measureSlant(glyphset, glyphs=None):
"""Measure the perceptual average slant angle of the given glyphs."""
if isinstance(glyphs, dict):
frequencies = glyphs
else:
frequencies = {g: 1 for g in glyphs}
slnt_sum = 0
freq_sum = 0
for glyph_name in glyphs:
if frequencies is not None:
frequency = frequencies.get(glyph_name, 0)
if frequency == 0:
continue
else:
frequency = 1
glyph = glyphset[glyph_name]
pen = StatisticsPen(glyphset=glyphset)
glyph.draw(pen)
mult = glyph.width * frequency
slnt_sum += mult * pen.slant
freq_sum += mult
return -math.degrees(math.atan(slnt_sum / freq_sum))
def sanitizeWidth(userTriple, designTriple, pins, measurements):
"""Sanitize the width axis limits."""
minVal, defaultVal, maxVal = (
measurements[designTriple[0]],
measurements[designTriple[1]],
measurements[designTriple[2]],
)
calculatedMinVal = userTriple[1] * (minVal / defaultVal)
calculatedMaxVal = userTriple[1] * (maxVal / defaultVal)
log.info("Original width axis limits: %g:%g:%g", *userTriple)
log.info(
"Calculated width axis limits: %g:%g:%g",
calculatedMinVal,
userTriple[1],
calculatedMaxVal,
)
if (
abs(calculatedMinVal - userTriple[0]) / userTriple[1] > 0.05
or abs(calculatedMaxVal - userTriple[2]) / userTriple[1] > 0.05
):
log.warning("Calculated width axis min/max do not match user input.")
log.warning(
" Current width axis limits: %g:%g:%g",
*userTriple,
)
log.warning(
" Suggested width axis limits: %g:%g:%g",
calculatedMinVal,
userTriple[1],
calculatedMaxVal,
)
return False
return True
def sanitizeWeight(userTriple, designTriple, pins, measurements):
"""Sanitize the weight axis limits."""
if len(set(userTriple)) < 3:
return True
minVal, defaultVal, maxVal = (
measurements[designTriple[0]],
measurements[designTriple[1]],
measurements[designTriple[2]],
)
logMin = math.log(minVal)
logDefault = math.log(defaultVal)
logMax = math.log(maxVal)
t = (userTriple[1] - userTriple[0]) / (userTriple[2] - userTriple[0])
y = math.exp(logMin + t * (logMax - logMin))
t = (y - minVal) / (maxVal - minVal)
calculatedDefaultVal = userTriple[0] + t * (userTriple[2] - userTriple[0])
log.info("Original weight axis limits: %g:%g:%g", *userTriple)
log.info(
"Calculated weight axis limits: %g:%g:%g",
userTriple[0],
calculatedDefaultVal,
userTriple[2],
)
if abs(calculatedDefaultVal - userTriple[1]) / userTriple[1] > 0.05:
log.warning("Calculated weight axis default does not match user input.")
log.warning(
" Current weight axis limits: %g:%g:%g",
*userTriple,
)
log.warning(
" Suggested weight axis limits, changing default: %g:%g:%g",
userTriple[0],
calculatedDefaultVal,
userTriple[2],
)
t = (userTriple[2] - userTriple[0]) / (userTriple[1] - userTriple[0])
y = math.exp(logMin + t * (logDefault - logMin))
t = (y - minVal) / (defaultVal - minVal)
calculatedMaxVal = userTriple[0] + t * (userTriple[1] - userTriple[0])
log.warning(
" Suggested weight axis limits, changing maximum: %g:%g:%g",
userTriple[0],
userTriple[1],
calculatedMaxVal,
)
t = (userTriple[0] - userTriple[2]) / (userTriple[1] - userTriple[2])
y = math.exp(logMax + t * (logDefault - logMax))
t = (y - maxVal) / (defaultVal - maxVal)
calculatedMinVal = userTriple[2] + t * (userTriple[1] - userTriple[2])
log.warning(
" Suggested weight axis limits, changing minimum: %g:%g:%g",
calculatedMinVal,
userTriple[1],
userTriple[2],
)
return False
return True
def sanitizeSlant(userTriple, designTriple, pins, measurements):
"""Sanitize the slant axis limits."""
log.info("Original slant axis limits: %g:%g:%g", *userTriple)
log.info(
"Calculated slant axis limits: %g:%g:%g",
measurements[designTriple[0]],
measurements[designTriple[1]],
measurements[designTriple[2]],
)
if (
abs(measurements[designTriple[0]] - userTriple[0]) > 1
or abs(measurements[designTriple[1]] - userTriple[1]) > 1
or abs(measurements[designTriple[2]] - userTriple[2]) > 1
):
log.warning("Calculated slant axis min/default/max do not match user input.")
log.warning(
" Current slant axis limits: %g:%g:%g",
*userTriple,
)
log.warning(
" Suggested slant axis limits: %g:%g:%g",
measurements[designTriple[0]],
measurements[designTriple[1]],
measurements[designTriple[2]],
)
return False
return True
def planAxis(
measureFunc,
normalizeFunc,
interpolateFunc,
glyphSetFunc,
axisTag,
axisLimits,
values,
samples=None,
glyphs=None,
designLimits=None,
pins=None,
sanitizeFunc=None,
):
"""Plan an axis.
measureFunc: callable that takes a glyphset and an optional
list of glyphnames, and returns the glyphset-wide measurement
to be used for the axis.
normalizeFunc: callable that takes a measurement and a minimum
and maximum, and normalizes the measurement into the range 0..1,
possibly extrapolating too.
interpolateFunc: callable that takes a normalized t value, and a
minimum and maximum, and returns the interpolated value,
possibly extrapolating too.
glyphSetFunc: callable that takes a variations "location" dictionary,
and returns a glyphset.
axisTag: the axis tag string.
axisLimits: a triple of minimum, default, and maximum values for
the axis. Or an `fvar` Axis object.
values: a list of output values to map for this axis.
samples: the number of samples to use when sampling. Default 8.
glyphs: a list of glyph names to use when sampling. Defaults to None,
which will process all glyphs.
designLimits: an optional triple of minimum, default, and maximum values
represenging the "design" limits for the axis. If not provided, the
axisLimits will be used.
pins: an optional dictionary of before/after mapping entries to pin in
the output.
sanitizeFunc: an optional callable to call to sanitize the axis limits.
"""
if isinstance(axisLimits, fvarAxis):
axisLimits = (axisLimits.minValue, axisLimits.defaultValue, axisLimits.maxValue)
minValue, defaultValue, maxValue = axisLimits
if samples is None:
samples = SAMPLES
if glyphs is None:
glyphs = glyphSetFunc({}).keys()
if pins is None:
pins = {}
else:
pins = pins.copy()
log.info(
"Axis limits min %g / default %g / max %g", minValue, defaultValue, maxValue
)
triple = (minValue, defaultValue, maxValue)
if designLimits is not None:
log.info("Axis design-limits min %g / default %g / max %g", *designLimits)
else:
designLimits = triple
if pins:
log.info("Pins %s", sorted(pins.items()))
pins.update(
{
minValue: designLimits[0],
defaultValue: designLimits[1],
maxValue: designLimits[2],
}
)
out = {}
outNormalized = {}
axisMeasurements = {}
for value in sorted({minValue, defaultValue, maxValue} | set(pins.keys())):
glyphset = glyphSetFunc(location={axisTag: value})
designValue = pins[value]
axisMeasurements[designValue] = measureFunc(glyphset, glyphs)
if sanitizeFunc is not None:
log.info("Sanitizing axis limit values for the `%s` axis.", axisTag)
sanitizeFunc(triple, designLimits, pins, axisMeasurements)
log.debug("Calculated average value:\n%s", pformat(axisMeasurements))
for (rangeMin, targetMin), (rangeMax, targetMax) in zip(
list(sorted(pins.items()))[:-1],
list(sorted(pins.items()))[1:],
):
targetValues = {w for w in values if rangeMin < w < rangeMax}
if not targetValues:
continue
normalizedMin = normalizeValue(rangeMin, triple)
normalizedMax = normalizeValue(rangeMax, triple)
normalizedTargetMin = normalizeValue(targetMin, designLimits)
normalizedTargetMax = normalizeValue(targetMax, designLimits)
log.info("Planning target values %s.", sorted(targetValues))
log.info("Sampling %u points in range %g,%g.", samples, rangeMin, rangeMax)
valueMeasurements = axisMeasurements.copy()
for sample in range(1, samples + 1):
value = rangeMin + (rangeMax - rangeMin) * sample / (samples + 1)
log.debug("Sampling value %g.", value)
glyphset = glyphSetFunc(location={axisTag: value})
designValue = piecewiseLinearMap(value, pins)
valueMeasurements[designValue] = measureFunc(glyphset, glyphs)
log.debug("Sampled average value:\n%s", pformat(valueMeasurements))
measurementValue = {}
for value in sorted(valueMeasurements):
measurementValue[valueMeasurements[value]] = value
out[rangeMin] = targetMin
outNormalized[normalizedMin] = normalizedTargetMin
for value in sorted(targetValues):
t = normalizeFunc(value, rangeMin, rangeMax)
targetMeasurement = interpolateFunc(
t, valueMeasurements[targetMin], valueMeasurements[targetMax]
)
targetValue = piecewiseLinearMap(targetMeasurement, measurementValue)
log.debug("Planned mapping value %g to %g." % (value, targetValue))
out[value] = targetValue
valueNormalized = normalizedMin + (value - rangeMin) / (
rangeMax - rangeMin
) * (normalizedMax - normalizedMin)
outNormalized[valueNormalized] = normalizedTargetMin + (
targetValue - targetMin
) / (targetMax - targetMin) * (normalizedTargetMax - normalizedTargetMin)
out[rangeMax] = targetMax
outNormalized[normalizedMax] = normalizedTargetMax
log.info("Planned mapping for the `%s` axis:\n%s", axisTag, pformat(out))
log.info(
"Planned normalized mapping for the `%s` axis:\n%s",
axisTag,
pformat(outNormalized),
)
if all(abs(k - v) < 0.01 for k, v in outNormalized.items()):
log.info("Detected identity mapping for the `%s` axis. Dropping.", axisTag)
out = {}
outNormalized = {}
return out, outNormalized
def planWeightAxis(
glyphSetFunc,
axisLimits,
weights=None,
samples=None,
glyphs=None,
designLimits=None,
pins=None,
sanitize=False,
):
"""Plan a weight (`wght`) axis.
weights: A list of weight values to plan for. If None, the default
values are used.
This function simply calls planAxis with values=weights, and the appropriate
arguments. See documenation for planAxis for more information.
"""
if weights is None:
weights = WEIGHTS
return planAxis(
measureWeight,
normalizeLinear,
interpolateLog,
glyphSetFunc,
"wght",
axisLimits,
values=weights,
samples=samples,
glyphs=glyphs,
designLimits=designLimits,
pins=pins,
sanitizeFunc=sanitizeWeight if sanitize else None,
)
def planWidthAxis(
glyphSetFunc,
axisLimits,
widths=None,
samples=None,
glyphs=None,
designLimits=None,
pins=None,
sanitize=False,
):
"""Plan a width (`wdth`) axis.
widths: A list of width values (percentages) to plan for. If None, the default
values are used.
This function simply calls planAxis with values=widths, and the appropriate
arguments. See documenation for planAxis for more information.
"""
if widths is None:
widths = WIDTHS
return planAxis(
measureWidth,
normalizeLinear,
interpolateLinear,
glyphSetFunc,
"wdth",
axisLimits,
values=widths,
samples=samples,
glyphs=glyphs,
designLimits=designLimits,
pins=pins,
sanitizeFunc=sanitizeWidth if sanitize else None,
)
def planSlantAxis(
glyphSetFunc,
axisLimits,
slants=None,
samples=None,
glyphs=None,
designLimits=None,
pins=None,
sanitize=False,
):
"""Plan a slant (`slnt`) axis.
slants: A list slant angles to plan for. If None, the default
values are used.
This function simply calls planAxis with values=slants, and the appropriate
arguments. See documenation for planAxis for more information.
"""
if slants is None:
slants = SLANTS
return planAxis(
measureSlant,
normalizeDegrees,
interpolateLinear,
glyphSetFunc,
"slnt",
axisLimits,
values=slants,
samples=samples,
glyphs=glyphs,
designLimits=designLimits,
pins=pins,
sanitizeFunc=sanitizeSlant if sanitize else None,
)
def planOpticalSizeAxis(
glyphSetFunc,
axisLimits,
sizes=None,
samples=None,
glyphs=None,
designLimits=None,
pins=None,
sanitize=False,
):
"""Plan a optical-size (`opsz`) axis.
sizes: A list of optical size values to plan for. If None, the default
values are used.
This function simply calls planAxis with values=sizes, and the appropriate
arguments. See documenation for planAxis for more information.
"""
if sizes is None:
sizes = SIZES
return planAxis(
measureWeight,
normalizeLog,
interpolateLog,
glyphSetFunc,
"opsz",
axisLimits,
values=sizes,
samples=samples,
glyphs=glyphs,
designLimits=designLimits,
pins=pins,
)
def makeDesignspaceSnippet(axisTag, axisName, axisLimit, mapping):
"""Make a designspace snippet for a single axis."""
designspaceSnippet = (
' <axis tag="%s" name="%s" minimum="%g" default="%g" maximum="%g"'
% ((axisTag, axisName) + axisLimit)
)
if mapping:
designspaceSnippet += ">\n"
else:
designspaceSnippet += "/>"
for key, value in mapping.items():
designspaceSnippet += ' <map input="%g" output="%g"/>\n' % (key, value)
if mapping:
designspaceSnippet += " </axis>"
return designspaceSnippet
def addEmptyAvar(font):
"""Add an empty `avar` table to the font."""
font["avar"] = avar = newTable("avar")
for axis in fvar.axes:
avar.segments[axis.axisTag] = {}
def processAxis(
font,
planFunc,
axisTag,
axisName,
values,
samples=None,
glyphs=None,
designLimits=None,
pins=None,
sanitize=False,
plot=False,
):
"""Process a single axis."""
axisLimits = None
for axis in font["fvar"].axes:
if axis.axisTag == axisTag:
axisLimits = axis
break
if axisLimits is None:
return ""
axisLimits = (axisLimits.minValue, axisLimits.defaultValue, axisLimits.maxValue)
log.info("Planning %s axis.", axisName)
if "avar" in font:
existingMapping = font["avar"].segments[axisTag]
font["avar"].segments[axisTag] = {}
else:
existingMapping = None
if values is not None and isinstance(values, str):
values = [float(w) for w in values.split()]
if designLimits is not None and isinstance(designLimits, str):
designLimits = [float(d) for d in options.designLimits.split(":")]
assert (
len(designLimits) == 3
and designLimits[0] <= designLimits[1] <= designLimits[2]
)
else:
designLimits = None
if pins is not None and isinstance(pins, str):
newPins = {}
for pin in pins.split():
before, after = pin.split(":")
newPins[float(before)] = float(after)
pins = newPins
del newPins
mapping, mappingNormalized = planFunc(
font.getGlyphSet,
axisLimits,
values,
samples=samples,
glyphs=glyphs,
designLimits=designLimits,
pins=pins,
sanitize=sanitize,
)
if plot:
from matplotlib import pyplot
pyplot.plot(
sorted(mappingNormalized),
[mappingNormalized[k] for k in sorted(mappingNormalized)],
)
pyplot.show()
if existingMapping is not None:
log.info("Existing %s mapping:\n%s", axisName, pformat(existingMapping))
if mapping:
if "avar" not in font:
addEmptyAvar(font)
font["avar"].segments[axisTag] = mappingNormalized
else:
if "avar" in font:
font["avar"].segments[axisTag] = {}
designspaceSnippet = makeDesignspaceSnippet(
axisTag,
axisName,
axisLimits,
mapping,
)
return designspaceSnippet
def main(args=None):
"""Plan the standard axis mappings for a variable font"""
if args is None:
import sys
args = sys.argv[1:]
from fontTools import configLogger
from fontTools.ttLib import TTFont
import argparse
parser = argparse.ArgumentParser(
"fonttools varLib.avarPlanner",
description="Plan `avar` table for variable font",
)
parser.add_argument("font", metavar="varfont.ttf", help="Variable-font file.")
parser.add_argument(
"-o",
"--output-file",
type=str,
help="Output font file name.",
)
parser.add_argument(
"--weights", type=str, help="Space-separate list of weights to generate."
)
parser.add_argument(
"--widths", type=str, help="Space-separate list of widths to generate."
)
parser.add_argument(
"--slants", type=str, help="Space-separate list of slants to generate."
)
parser.add_argument(
"--sizes", type=str, help="Space-separate list of optical-sizes to generate."
)
parser.add_argument("--samples", type=int, help="Number of samples.")
parser.add_argument(
"-s", "--sanitize", action="store_true", help="Sanitize axis limits"
)
parser.add_argument(
"-g",
"--glyphs",
type=str,
help="Space-separate list of glyphs to use for sampling.",
)
parser.add_argument(
"--weight-design-limits",
type=str,
help="min:default:max in design units for the `wght` axis.",
)
parser.add_argument(
"--width-design-limits",
type=str,
help="min:default:max in design units for the `wdth` axis.",
)
parser.add_argument(
"--slant-design-limits",
type=str,
help="min:default:max in design units for the `slnt` axis.",
)
parser.add_argument(
"--optical-size-design-limits",
type=str,
help="min:default:max in design units for the `opsz` axis.",
)
parser.add_argument(
"--weight-pins",
type=str,
help="Space-separate list of before:after pins for the `wght` axis.",
)
parser.add_argument(
"--width-pins",
type=str,
help="Space-separate list of before:after pins for the `wdth` axis.",
)
parser.add_argument(
"--slant-pins",
type=str,
help="Space-separate list of before:after pins for the `slnt` axis.",
)
parser.add_argument(
"--optical-size-pins",
type=str,
help="Space-separate list of before:after pins for the `opsz` axis.",
)
parser.add_argument(
"-p", "--plot", action="store_true", help="Plot the resulting mapping."
)
logging_group = parser.add_mutually_exclusive_group(required=False)
logging_group.add_argument(
"-v", "--verbose", action="store_true", help="Run more verbosely."
)
logging_group.add_argument(
"-q", "--quiet", action="store_true", help="Turn verbosity off."
)
options = parser.parse_args(args)
configLogger(
level=("DEBUG" if options.verbose else "WARNING" if options.quiet else "INFO")
)
font = TTFont(options.font)
if not "fvar" in font:
log.error("Not a variable font.")
return 1
if options.glyphs is not None:
glyphs = options.glyphs.split()
if ":" in options.glyphs:
glyphs = {}
for g in options.glyphs.split():
if ":" in g:
glyph, frequency = g.split(":")
glyphs[glyph] = float(frequency)
else:
glyphs[g] = 1.0
else:
glyphs = None
designspaceSnippets = []
designspaceSnippets.append(
processAxis(
font,
planWeightAxis,
"wght",
"Weight",
values=options.weights,
samples=options.samples,
glyphs=glyphs,
designLimits=options.weight_design_limits,
pins=options.weight_pins,
sanitize=options.sanitize,
plot=options.plot,
)
)
designspaceSnippets.append(
processAxis(
font,
planWidthAxis,
"wdth",
"Width",
values=options.widths,
samples=options.samples,
glyphs=glyphs,
designLimits=options.width_design_limits,
pins=options.width_pins,
sanitize=options.sanitize,
plot=options.plot,
)
)
designspaceSnippets.append(
processAxis(
font,
planSlantAxis,
"slnt",
"Slant",
values=options.slants,
samples=options.samples,
glyphs=glyphs,
designLimits=options.slant_design_limits,
pins=options.slant_pins,
sanitize=options.sanitize,
plot=options.plot,
)
)
designspaceSnippets.append(
processAxis(
font,
planOpticalSizeAxis,
"opsz",
"OpticalSize",
values=options.sizes,
samples=options.samples,
glyphs=glyphs,
designLimits=options.optical_size_design_limits,
pins=options.optical_size_pins,
sanitize=options.sanitize,
plot=options.plot,
)
)
log.info("Designspace snippet:")
for snippet in designspaceSnippets:
if snippet:
print(snippet)
if options.output_file is None:
outfile = makeOutputFileName(options.font, overWrite=True, suffix=".avar")
else:
outfile = options.output_file
if outfile:
log.info("Saving %s", outfile)
font.save(outfile)
if __name__ == "__main__":
import sys
sys.exit(main())