Merge pull request #635 from googlefonts/compile-variable-features

Compile variable features

Lib/ufo2ft/__init__.py

@@ -18,6 +18,11 @@
  "compileVariableCFF2s",
 ]
 
+try:
+ from ._version import version as __version__
+except ImportError:
+ __version__ = "0.0.0+unknown"
+
 
 def compileTTF(ufo, **kwargs):
  """Create FontTools TrueType font from a UFO.
@@ -168,6 +173,30 @@ def compileVariableTTFs(designSpaceDoc, **kwargs):
 
 
 def compileInterpolatableTTFsFromDS(designSpaceDoc, **kwargs):
+ """Create FontTools TrueType fonts from the DesignSpaceDocument UFO sources
+ with interpolatable outlines. Cubic curves are converted compatibly to
+ quadratic curves using the Cu2Qu conversion algorithm.
+
+ If the Designspace contains a "public.skipExportGlyphs" lib key, these
+ glyphs will not be exported to the final font. If these glyphs are used as
+ components in any other glyph, those components get decomposed. If the lib
+ key doesn't exist in the Designspace, all glyphs are exported (keys in
+ individual UFOs are ignored). UFO groups and kerning will be pruned of
+ skipped glyphs.
+
+ The DesignSpaceDocument should contain SourceDescriptor objects with 'font'
+ attribute set to an already loaded defcon.Font object (or compatible UFO
+ Font class). If 'font' attribute is unset or None, an AttributeError exception
+ is thrown.
+
+ Return a copy of the DesignSpaceDocument object (or the same one if
+ inplace=True) with the source's 'font' attribute set to the corresponding
+ TTFont instance.
+
+ For sources that have the 'layerName' attribute defined, the corresponding TTFont
+ object will contain only a minimum set of tables ("head", "hmtx", "glyf", "loca",
+ "maxp", "post" and "vmtx"), and no OpenType layout tables.
+ """
  return InterpolatableTTFCompiler(**kwargs).compile_designspace(designSpaceDoc)
 
 

Lib/ufo2ft/_compilers/baseCompiler.py

@@ -4,13 +4,19 @@
 from dataclasses import dataclass
 from typing import Callable, Optional, Type
 
+from fontTools import varLib
 from fontTools.designspaceLib.split import splitInterpolable, splitVariableFonts
 from fontTools.misc.loggingTools import Timer
 from fontTools.otlLib.optimize.gpos import GPOS_COMPACT_MODE_ENV_KEY
 
 from ufo2ft.constants import MTI_FEATURES_PREFIX
 from ufo2ft.errors import InvalidDesignSpaceData
-from ufo2ft.featureCompiler import FeatureCompiler, MtiFeatureCompiler
+from ufo2ft.featureCompiler import (
+ FeatureCompiler,
+ MtiFeatureCompiler,
+ VariableFeatureCompiler,
+ _featuresCompatible,
+)
 from ufo2ft.postProcessor import PostProcessor
 from ufo2ft.util import (
  _notdefGlyphFallback,
@@ -51,6 +57,7 @@ def compile(self, ufo):
  with self.timer("preprocess UFO"):
  glyphSet = self.preprocess(ufo)
  with self.timer("compile a basic TTF"):
+ self.logger.info("Building OpenType tables")
  font = self.compileOutlines(ufo, glyphSet)
  if self.layerName is None and not self.skipFeatureCompilation:
  self.compileFeatures(ufo, font, glyphSet=glyphSet)
@@ -169,8 +176,13 @@ class BaseInterpolatableCompiler(BaseCompiler):
  "maxp", "post" and "vmtx"), and no OpenType layout tables.
  """
 
+ def compile_designspace(self, designSpaceDoc):
+ ufos = self._pre_compile_designspace(designSpaceDoc)
+ ttfs = self.compile(ufos)
+ return self._post_compile_designspace(designSpaceDoc, ttfs)
+
  def _pre_compile_designspace(self, designSpaceDoc):
- ufos, self.layerNames = [], []
+ ufos, self.glyphSets, self.layerNames = [], [], []
  for source in designSpaceDoc.sources:
  if source.font is None:
  raise AttributeError(
@@ -246,7 +258,16 @@ def _compileNeededSources(self, designSpaceDoc):
  if source.name in sourcesToCompile:
  sourcesByName[source.name] = source
 
+ # If the feature files are compatible between the sources, we can save
+ # time by building a variable feature file right at the end.
+ can_optimize_features = self.variableFeatures and _featuresCompatible(
+ designSpaceDoc
+ )
+ if can_optimize_features:
+ self.logger.info("Features are compatible across masters; building later")
+
  originalSources = {}
+ originalGlyphsets = {}
 
  # Compile all needed sources in each interpolable subspace to make sure
  # they're all compatible; that also ensures that sub-vfs within the same
@@ -265,6 +286,7 @@ def _compileNeededSources(self, designSpaceDoc):
  self.useProductionNames = False
  save_postprocessor = self.postProcessorClass
  self.postProcessorClass = None
+ self.skipFeatureCompilation = can_optimize_features
  try:
  ttfDesignSpace = self.compile_designspace(subDoc)
  finally:
@@ -274,33 +296,96 @@ def _compileNeededSources(self, designSpaceDoc):
  self.useProductionNames = save_production_names
 
  # Stick TTFs back into original big DS
- for ttfSource in ttfDesignSpace.sources:
+ for ttfSource, glyphSet in zip(ttfDesignSpace.sources, self.glyphSets):
+ if can_optimize_features:
+ originalSources[ttfSource.name] = sourcesByName[ttfSource.name].font
  sourcesByName[ttfSource.name].font = ttfSource.font
+ originalGlyphsets[ttfSource.name] = glyphSet
 
- return vfNameToBaseUfo, originalSources
+ return (
+ vfNameToBaseUfo,
+ can_optimize_features,
+ originalSources,
+ originalGlyphsets,
+ )
 
  def compile_variable(self, designSpaceDoc):
  if not self.inplace:
  designSpaceDoc = designSpaceDoc.deepcopyExceptFonts()
 
  (
  vfNameToBaseUfo,
+ buildVariableFeatures,
  originalSources,
+ originalGlyphsets,
  ) = self._compileNeededSources(designSpaceDoc)
 
  if not vfNameToBaseUfo:
  return {}
 
- self.logger.info("Building variable TTF fonts: %s", ", ".join(vfNameToBaseUfo))
+ vfNames = list(vfNameToBaseUfo.keys())
+ self.logger.info(
+ "Building variable font%s: %s",
+ "s" if len(vfNames) > 1 else "",
+ ", ".join(vfNames),
+ )
 
  excludeVariationTables = self.excludeVariationTables
+ if buildVariableFeatures:
+ # Skip generating feature variations in varLib; we are handling
+ # the feature variations as part of compiling variable features,
+ # which we'll do later, so we don't need to produce them here.
+ excludeVariationTables = set(excludeVariationTables) | {"GSUB"}
 
  with self.timer("merge fonts to variable"):
  vfNameToTTFont = self._merge(designSpaceDoc, excludeVariationTables)
 
+ if buildVariableFeatures:
+ self.compile_all_variable_features(
+ designSpaceDoc, vfNameToTTFont, originalSources, originalGlyphsets
+ )
  for vfName, varfont in list(vfNameToTTFont.items()):
  vfNameToTTFont[vfName] = self.postprocess(
  varfont, vfNameToBaseUfo[vfName], glyphSet=None
  )
 
  return vfNameToTTFont
+
+ def compile_all_variable_features(
+ self,
+ designSpaceDoc,
+ vfNameToTTFont,
+ originalSources,
+ originalGlyphsets,
+ debugFeatureFile=False,
+ ):
+ interpolableSubDocs = [
+ subDoc for _location, subDoc in splitInterpolable(designSpaceDoc)
+ ]
+ for subDoc in interpolableSubDocs:
+ for vfName, vfDoc in splitVariableFonts(subDoc):
+ if vfName not in vfNameToTTFont:
+ continue
+ ttFont = vfNameToTTFont[vfName]
+ # vfDoc is now full of TTFs, create a UFO-sourced equivalent
+ ufoDoc = vfDoc.deepcopyExceptFonts()
+ for ttfSource, ufoSource in zip(vfDoc.sources, ufoDoc.sources):
+ ufoSource.font = originalSources[ttfSource.name]
+ defaultGlyphset = originalGlyphsets[ufoDoc.findDefault().name]
+ self.logger.info(f"Compiling variable features for {vfName}")
+ self.compile_variable_features(ufoDoc, ttFont, defaultGlyphset)
+
+ def compile_variable_features(self, designSpaceDoc, ttFont, glyphSet):
+ default_ufo = designSpaceDoc.findDefault().font
+
+ featureCompiler = VariableFeatureCompiler(
+ default_ufo, designSpaceDoc, ttFont=ttFont, glyphSet=glyphSet
+ )
+ featureCompiler.compile()
+
+ if self.debugFeatureFile:
+ if hasattr(featureCompiler, "writeFeatures"):
+ featureCompiler.writeFeatures(self.debugFeatureFile)
+
+ # Add back feature variations, as the code above would overwrite them.
+ varLib.addGSUBFeatureVariations(ttFont, designSpaceDoc)

Lib/ufo2ft/_compilers/interpolatableOTFCompiler.py

@@ -7,6 +7,7 @@
 from ufo2ft.constants import SPARSE_OTF_MASTER_TABLES, CFFOptimization
 from ufo2ft.outlineCompiler import OutlineOTFCompiler
 from ufo2ft.preProcessor import OTFPreProcessor
+from ufo2ft.util import prune_unknown_kwargs
 
 from .baseCompiler import BaseInterpolatableCompiler
 from .otfCompiler import OTFCompiler
@@ -28,31 +29,34 @@ class InterpolatableOTFCompiler(OTFCompiler, BaseInterpolatableCompiler):
  skipFeatureCompilation: bool = False
  excludeVariationTables: tuple = ()
 
- def compile_designspace(self, designSpaceDoc):
- self._pre_compile_designspace(designSpaceDoc)
+ # We can't use the same compile method as interpolatableTTFCompiler
+ # because that has a TTFInterpolatablePreProcessor which preprocesses
+ # all UFOs together, whereas we need to do the preprocessing one at
+ # at a time.
+ def compile(self, ufos):
  otfs = []
- for source in designSpaceDoc.sources:
+ for ufo, layerName in zip(ufos, self.layerNames):
  # There's a Python bug where dataclasses.asdict() doesn't work with
  # dataclasses that contain a defaultdict.
  save_extraSubstitutions = self.extraSubstitutions
  self.extraSubstitutions = None
  args = {
  **dataclasses.asdict(self),
  **dict(
- layerName=source.layerName,
+ layerName=layerName,
  removeOverlaps=False,
  overlapsBackend=None,
  optimizeCFF=CFFOptimization.NONE,
- _tables=SPARSE_OTF_MASTER_TABLES if source.layerName else None,
+ _tables=SPARSE_OTF_MASTER_TABLES if layerName else None,
  ),
  }
  # Remove interpolatable-specific args
- del args["variableFontNames"]
- del args["excludeVariationTables"]
+ args = prune_unknown_kwargs(args, OTFCompiler)
  compiler = OTFCompiler(**args)
  self.extraSubstitutions = save_extraSubstitutions
- otfs.append(compiler.compile(source.font))
- return self._post_compile_designspace(designSpaceDoc, otfs)
+ otfs.append(compiler.compile(ufo))
+ self.glyphSets.append(compiler._glyphSet)
+ return otfs
 
  def _merge(self, designSpaceDoc, excludeVariationTables):
  return varLib.build_many(

Lib/ufo2ft/_compilers/interpolatableTTFCompiler.py

@@ -31,9 +31,9 @@ def compile(self, ufos):
  if self.layerNames is None:
  self.layerNames = [None] * len(ufos)
  assert len(ufos) == len(self.layerNames)
- glyphSets = self.preprocess(ufos)
+ self.glyphSets = self.preprocess(ufos)
 
- for ufo, glyphSet, layerName in zip(ufos, glyphSets, self.layerNames):
+ for ufo, glyphSet, layerName in zip(ufos, self.glyphSets, self.layerNames):
  yield self.compile_one(ufo, glyphSet, layerName)
 
  def compile_one(self, ufo, glyphSet, layerName):
@@ -78,11 +78,6 @@ def compileOutlines(self, ufo, glyphSet, layerName=None):
  outlineCompiler = self.outlineCompilerClass(ufo, glyphSet=glyphSet, **kwargs)
  return outlineCompiler.compile()
 
- def compile_designspace(self, designSpaceDoc):
- ufos = self._pre_compile_designspace(designSpaceDoc)
- ttfs = self.compile(ufos)
- return self._post_compile_designspace(designSpaceDoc, ttfs)
-
  def _merge(self, designSpaceDoc, excludeVariationTables):
  return varLib.build_many(
  designSpaceDoc,

Lib/ufo2ft/_compilers/otfCompiler.py

@@ -33,4 +33,5 @@ def postprocess(self, font, ufo, glyphSet):
  kwargs = prune_unknown_kwargs(self.__dict__, postProcessor.process)
  kwargs["optimizeCFF"] = self.optimizeCFF >= CFFOptimization.SUBROUTINIZE
  font = postProcessor.process(**kwargs)
+ self._glyphSet = glyphSet
  return font

Lib/ufo2ft/_compilers/ttfCompiler.py

@@ -21,7 +21,7 @@ class TTFCompiler(BaseCompiler):
  dropImpliedOnCurves: bool = False
  allQuadratic: bool = True
 
- def compileOutlines(self, ufo, glyphSet, layerName=None):
+ def compileOutlines(self, ufo, glyphSet):
  kwargs = prune_unknown_kwargs(self.__dict__, self.outlineCompilerClass)
  kwargs["glyphDataFormat"] = 0 if self.allQuadratic else 1
  outlineCompiler = self.outlineCompilerClass(ufo, glyphSet=glyphSet, **kwargs)

Lib/ufo2ft/_compilers/variableCFF2sCompiler.py

@@ -17,3 +17,4 @@ class VariableCFF2sCompiler(InterpolatableOTFCompiler):
  cffVersion: int = 2
  optimizeCFF: CFFOptimization = CFFOptimization.SPECIALIZE
  excludeVariationTables: tuple = ()
+ variableFeatures: bool = True

Lib/ufo2ft/_compilers/variableTTFsCompiler.py

@@ -21,4 +21,4 @@ class VariableTTFsCompiler(InterpolatableTTFCompiler):
  autoUseMyMetrics: bool = True
  dropImpliedOnCurves: bool = False
  allQuadratic: bool = True
- pass
+ variableFeatures: bool = True

Lib/ufo2ft/featureCompiler.py

@@ -9,6 +9,7 @@
 from tempfile import NamedTemporaryFile
 
 from fontTools import mtiLib
+from fontTools.designspaceLib import DesignSpaceDocument, SourceDescriptor
 from fontTools.feaLib.builder import addOpenTypeFeaturesFromString
 from fontTools.feaLib.error import FeatureLibError, IncludedFeaNotFound
 from fontTools.feaLib.parser import Parser
@@ -102,6 +103,10 @@ def __init__(self, ufo, ttFont=None, glyphSet=None, extraSubstitutions=None):
 
  glyphOrder = ttFont.getGlyphOrder()
  if glyphSet is not None:
+ if set(glyphOrder) != set(glyphSet.keys()):
+ print("Glyph order incompatible")
+ print("In UFO but not in font:", set(glyphSet.keys()) - set(glyphOrder))
+ print("In font but not in UFO:", set(glyphOrder) - set(glyphSet.keys()))
  assert set(glyphOrder) == set(glyphSet.keys())
  else:
  glyphSet = ufo
@@ -407,3 +412,56 @@ def warn_about_miscased_insertion_markers(
  text,
  pattern_case.pattern,
  )
+
+
+class VariableFeatureCompiler(FeatureCompiler):
+ """Generate a variable feature file and compile OpenType tables from a
+ designspace file.
+ """
+
+ def __init__(
+ self,
+ ufo,
+ designspace,
+ ttFont=None,
+ glyphSet=None,
+ featureWriters=None,
+ **kwargs,
+ ):
+ self.designspace = designspace
+ super().__init__(ufo, ttFont, glyphSet, featureWriters, **kwargs)
+
+ def setupFeatures(self):
+ if self.featureWriters:
+ featureFile = parseLayoutFeatures(self.ufo)
+
+ for writer in self.featureWriters:
+ writer.write(self.designspace, featureFile, compiler=self)
+
+ # stringify AST to get correct line numbers in error messages
+ self.features = featureFile.asFea()
+ else:
+ # no featureWriters, simply read existing features' text
+ self.features = self.ufo.features.text or ""
+
+
+def _featuresCompatible(designSpaceDoc: DesignSpaceDocument) -> bool:
+ """Returns whether the features of the individual source UFOs are the same.
+
+ NOTE: Only compares the feature file text inside the source UFO and does not
+ follow imports. This will suffice as long as no external feature file is
+ using variable syntax and all sources are stored n the same parent folder
+ (so the same includes point to the same files).
+ """
+
+ assert all(hasattr(source.font, "features") for source in designSpaceDoc.sources)
+
+ def transform(f: SourceDescriptor) -> str:
+ # Strip comments
+ text = re.sub("(?m)#.*$", "", f.font.features.text or "")
+ # Strip extraneous whitespace
+ text = re.sub(r"\s+", " ", text)
+ return text
+
+ first = transform(designSpaceDoc.sources[0])
+ return all(transform(s) == first for s in designSpaceDoc.sources[1:])