| 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()) |
