marseymoji/add_svg_glyphs.py

#!/usr/bin/env python
# Copyright 2015 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.
#
# Google Author(s): Doug Felt

"""Tool to update GSUB, hmtx, cmap, glyf tables with svg image glyphs."""

import argparse
import glob
import os
import re
import sys

# find the noto root, so we can get nototools
# alternatively we could just define PYTHONPATH or always run this from
# noto root, but for testing we might not always be doing that.
_noto_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '../..'))
sys.path.append(_noto_root)

from fontTools.ttLib.tables import otTables
from fontTools.ttLib.tables import _g_l_y_f
from fontTools.ttLib.tables import S_V_G_ as SVG
from fontTools import ttx

import add_emoji_gsub
import svg_builder
import svg_cleaner

class FontBuilder(object):
  """A utility for mutating a ttx font.  This maintains glyph_order, cmap, and hmtx tables,
  and optionally GSUB, glyf, and SVN tables as well."""

  def __init__(self, font):
    self.font = font;
    self.glyph_order = font.getGlyphOrder()
    self.cmap = font['cmap'].tables[0].cmap
    self.hmtx = font['hmtx'].metrics

  def init_gsub(self):
    """Call this if you are going to add ligatures to the font.  Creates a GSUB table
    if there isn't one already."""

    if hasattr(self, 'ligatures'):
      return
    font = self.font
    if 'GSUB' not in font:
      ligature_subst = otTables.LigatureSubst()
      ligature_subst.ligatures = {}

      lookup = otTables.Lookup()
      lookup.LookupType = 4
      lookup.LookupFlag = 0
      lookup.SubTableCount = 1
      lookup.SubTable = [ligature_subst]

      font['GSUB'] = add_emoji_gsub.create_simple_gsub([lookup])
    else:
      lookup = font['GSUB'].table.LookupList.Lookup[0]
      assert lookup.LookupType == 4
      assert lookup.LookupFlag == 0
    self.ligatures = lookup.SubTable[0].ligatures

  def init_glyf(self):
    """Call this if you need to create empty glyf entries in the font when you add a new
    glyph."""

    if hasattr(self, 'glyphs'):
      return
    font = self.font
    if 'glyf' not in font:
      glyf_table = _g_l_y_f.table__g_l_y_f()
      glyf_table.glyphs = {}
      glyf_table.glyphOrder = self.glyph_order
      font['glyf'] = glyf_table
    self.glyphs = font['glyf'].glyphs

  def init_svg(self):
    """Call this if you expect to add SVG images in the font. This calls init_glyf since SVG
    support currently requires fallback glyf records for each SVG image."""

    if hasattr(self, 'svgs'):
      return

    # svg requires glyf
    self.init_glyf()

    font = self.font
    if 'SVG ' not in font:
      svg_table = SVG.table_S_V_G_()
      svg_table.docList = []
      svg_table.colorPalettes = None
      font['SVG '] = svg_table
    self.svgs = font['SVG '].docList

  def glyph_name(self, string):
    return "_".join(["u%04X" % ord(char) for char in string])

  def glyph_name_to_index(self, name):
    return self.glyph_order.index(name) if name in self.glyph_order else -1;

  def glyph_index_to_name(self, glyph_index):
    if glyph_index < len(self.glyph_order):
      return self.glyph_order[glyph_index]
    return ''

  def have_glyph(self, name):
    return self.name_to_glyph_index >= 0

  def _add_ligature(self, glyphstr):
    lig = otTables.Ligature()
    lig.CompCount = len(glyphstr)
    lig.Component = [self.glyph_name(ch) for ch in glyphstr[1:]]
    lig.LigGlyph = self.glyph_name(glyphstr)

    first = self.glyph_name(glyphstr[0])
    try:
      self.ligatures[first].append(lig)
    except KeyError:
      self.ligatures[first] = [lig]

  def _add_empty_glyph(self, glyphstr, name):
    """Create an empty glyph. If glyphstr is not a ligature, add a cmap entry for it."""
    if len(glyphstr) == 1:
      self.cmap[ord(glyphstr)] = name
    self.hmtx[name] = [0, 0]
    self.glyph_order.append(name)
    if hasattr(self, 'glyphs'):
      self.glyphs[name] = _g_l_y_f.Glyph()

  def add_components_and_ligature(self, glyphstr):
    """Convert glyphstr to a name and check if it already exists. If not, check if it is a
    ligature (longer than one codepoint), and if it is, generate empty glyphs with cmap
    entries for any missing ligature components and add a ligature record.  Then generate
    an empty glyph for the name.  Return a tuple with the name, index, and a bool
    indicating whether the glyph already existed."""

    name = self.glyph_name(glyphstr)
    index = self.glyph_name_to_index(name)
    exists = index >= 0
    if not exists:
      if len(glyphstr) > 1:
        for char in glyphstr:
          if ord(char) not in self.cmap:
            char_name = self.glyph_name(char)
            self._add_empty_glyph(char, char_name)
        self._add_ligature(glyphstr)
      index = len(self.glyph_order)
      self._add_empty_glyph(glyphstr, name)
    return name, index, exists

  def add_svg(self, doc, hmetrics, name, index):
    """Add an svg table entry. If hmetrics is not None, update the hmtx table. This
    expects the glyph has already been added."""
    # sanity check to make sure name and index correspond.
    assert name == self.glyph_index_to_name(index)
    if hmetrics:
      self.hmtx[name] = hmetrics
    svg_record = (doc, index, index) # startGlyphId, endGlyphId are the same
    self.svgs.append(svg_record)


def collect_glyphstr_file_pairs(prefix, ext, include=None, exclude=None, verbosity=1):
  """Scan files with the given prefix and extension, and return a list of (glyphstr,
  filename) where glyphstr is the character or ligature, and filename is the image file
  associated with it.  The glyphstr is formed by decoding the filename (exclusive of the
  prefix) as a sequence of hex codepoints separated by underscore. Include, if defined, is
  a regex string to include only matched filenames. Exclude, if defined, is a regex string
  to exclude matched filenames, and is applied after include."""

  image_files = {}
  glob_pat = "%s*.%s" % (prefix, ext)
  leading = len(prefix)
  trailing = len(ext) + 1 # include dot
  if verbosity:
    print "Looking for images matching '%s'." % glob_pat
  ex_count = 0
  ex = re.compile(exclude) if exclude else None
  inc = re.compile(include) if include else None
  if verbosity and inc:
    print "Including images matching '%s'." % include
  if verbosity and ex:
    print "Excluding images matching '%s'." % exclude

  for image_file in glob.glob(glob_pat):
    if inc and not inc.search(image_file):
      continue

    if ex and ex.search(image_file):
      if verbosity > 1:
        print "Exclude %s" % image_file
      ex_count += 1
      continue

    codes = image_file[leading:-trailing]
    if "_" in codes:
      pieces = codes.split ("_")
      u = "".join ([unichr(int(code, 16)) for code in pieces])
    else:
      u = unichr(int(codes, 16))
    image_files[u] = image_file

  if verbosity and ex_count:
    print "Excluded %d files." % ex_count
  if not image_files:
    raise Exception ("No image files matching '%s'." % glob_pat)
  if verbosity:
    print "Included %s files." % len(image_files)
  return image_files.items()


def sort_glyphstr_tuples(glyphstr_tuples):
  """The list contains tuples whose first element is a string representing a character or
  ligature.  It is sorted with shorter glyphstrs first, then alphabetically. This ensures
  that ligature components are added to the font before any ligatures that contain them."""
  glyphstr_tuples.sort(key=lambda t: (len(t[0]), t[0]))


def add_image_glyphs(in_file, out_file, pairs, verbosity=1):
  """Add images from pairs (glyphstr, filename) to .ttx file in_file and write
  to .ttx file out_file."""

  quiet = verbosity < 2
  font = ttx.TTFont(quiet=quiet)
  font.importXML(in_file, quiet=quiet)

  sort_glyphstr_tuples(pairs)

  font_builder = FontBuilder(font)
  # we've already sorted by length, so the longest glyphstrs are at the end. To see if
  # we have ligatures, we just need to check the last one.
  if len(pairs[-1][0]) > 1:
    font_builder.init_gsub()

  img_builder = svg_builder.SvgBuilder(font_builder)
  for glyphstr, filename in pairs:
    if verbosity > 1:
      print "Adding glyph for U+%s" % ",".join(["%04X" % ord(char) for char in glyphstr])
    img_builder.add_from_filename(glyphstr, filename)

  font.saveXML(out_file, quiet=quiet)
  if verbosity:
    print "added %s images to %s" % (len(pairs), out_file)


def main(argv):
  usage = """This will search for files that have image_prefix followed by one or more
      hex numbers (separated by underscore if more than one), and end in ".svg".
      For example, if image_prefix is "icons/u", then files with names like
      "icons/u1F4A9.svg" or "icons/u1F1EF_1F1F5.svg" will be loaded.  The script
      then adds cmap, htmx, and potentially GSUB entries for the Unicode
      characters found.  The advance width will be chosen based on image aspect
      ratio.  If Unicode values outside the BMP are desired, the existing cmap
      table should be of the appropriate (format 12) type.  Only the first cmap
      table and the first GSUB lookup (if existing) are modified."""

  parser = argparse.ArgumentParser(
      description="Update cmap, glyf, GSUB, and hmtx tables from image glyphs.", epilog=usage)
  parser.add_argument('in_file', help="Input ttx file name.")
  parser.add_argument('out_file', help="Output ttx file name.")
  parser.add_argument('image_prefix', help="Location and prefix of image files.")
  parser.add_argument('-i', '--include', help='include files whoses name matches this regex')
  parser.add_argument('-e', '--exclude', help='exclude files whose name matches this regex')
  parser.add_argument('--quiet', '-q', dest='v', help="quiet operation.", default=1,
                      action='store_const', const=0)
  parser.add_argument('--verbose', '-v', dest='v', help="verbose operation.",
                      action='store_const', const=2)
  args = parser.parse_args(argv)

  pairs = collect_glyphstr_file_pairs(args.image_prefix, 'svg', include=args.include,
                                      exclude=args.exclude, verbosity=args.v)
  add_image_glyphs(args.in_file, args.out_file, pairs, verbosity=args.v)


if __name__ == '__main__':
  main(sys.argv[1:])