scripts/color_emoji_image_diff.py

#!/usr/bin/env python

# Copyright (C) 2018 The Android Open Source Project
#
# 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.

import contextlib
import itertools
import io
import os
import sys

from fontTools import ttLib
from PIL import Image

def to_hex_str(value):
    """Converts given int value to hex without the 0x prefix"""
    return format(value, 'X')

def codepoint_to_string(codepoints):
    """Converts a list of codepoints into a string separated with space."""
    return '_'.join([to_hex_str(x) for x in codepoints])

def read_cmap12(ttf, glyph_to_codepoint_map, codepoint_map):
    cmap = ttf['cmap']
    for table in cmap.tables:
        if table.format == 12 and table.platformID == 3 and table.platEncID == 10:
            for codepoint, glyph_name in table.cmap.iteritems():
                glyph_to_codepoint_map[glyph_name] = codepoint
                codepoint_map[codepoint_to_string([codepoint])] = glyph_name
                # self.update_emoji_data([codepoint], glyph_name)
            return table
    raise ValueError("Font doesn't contain cmap with format:12, platformID:3 and platEncID:10")

def read_gsub(ttf, glyph_to_codepoint_map, codepoint_map):
    gsub = ttf['GSUB']
    ligature_subtables = []
    context_subtables = []
    # this code is font dependent, implementing all gsub rules is out of scope of EmojiCompat
    # and would be expensive with little value
    for lookup in gsub.table.LookupList.Lookup:
        for subtable in lookup.SubTable:
            if subtable.LookupType == 5:
                context_subtables.append(subtable)
            elif subtable.LookupType == 4:
                ligature_subtables.append(subtable)

    for subtable in context_subtables:
        add_gsub_context_subtable(subtable, gsub.table.LookupList, glyph_to_codepoint_map, codepoint_map)

    for subtable in ligature_subtables:
        add_gsub_ligature_subtable(subtable, glyph_to_codepoint_map, codepoint_map)

def add_gsub_context_subtable(subtable, lookup_list, glyph_to_codepoint_map, codepoint_map):
    for sub_class_set in subtable.SubClassSet:
        if sub_class_set:
            for sub_class_rule in sub_class_set.SubClassRule:
                subs_list = len(sub_class_rule.SubstLookupRecord) * [None]
                for record in sub_class_rule.SubstLookupRecord:
                    subs_list[record.SequenceIndex] = get_substitutions(lookup_list,
                                                                        record.LookupListIndex)
                combinations = list(itertools.product(*subs_list))
                for seq in combinations:
                    glyph_names = [x["input"] for x in seq]
                    codepoints = [glyph_to_codepoint_map[x] for x in glyph_names]
                    outputs = [x["output"] for x in seq if x["output"]]
                    nonempty_outputs = filter(lambda x: x.strip() , outputs)
                    if len(nonempty_outputs) == 0:
                        print("Warning: no output glyph is set for " + str(glyph_names))
                        continue
                    elif len(nonempty_outputs) > 1:
                        print(
                            "Warning: multiple glyph is set for "
                                + str(glyph_names) + ", will use the first one")

                    glyph = nonempty_outputs[0]
                    codepoint_map[codepoint_to_string(codepoints)] = glyph

def get_substitutions(lookup_list, index):
    result = []
    for x in lookup_list.Lookup[index].SubTable:
        for input, output in x.mapping.iteritems():
            result.append({"input": input, "output": output})
    return result

def add_gsub_ligature_subtable(subtable, glyph_to_codepoint_map, codepoint_map):
    for name, ligatures in subtable.ligatures.iteritems():
        for ligature in ligatures:
            glyph_names = [name] + ligature.Component
            codepoints = [glyph_to_codepoint_map[x] for x in glyph_names]
            codepoint_map[codepoint_to_string(codepoints)] = ligature.LigGlyph

def read_cbdt(ttf):
  cbdt = ttf['CBDT']
  glyph_to_image = {}
  for strike_data in cbdt.strikeData:
    for key, data in strike_data.iteritems():
      data.decompile
      glyph_to_image[key] = Image.open(io.BytesIO(data.imageData))
  return glyph_to_image


rgba_map = {}

def similar_img(img1, img2):
    # return if images are the same with accepting some changes
    if img1 is None and img2 is None: return True
    if img1 is None or img2 is None: return False
    if not img1.size == img2.size: return False

    pixels1 = rgba_map.get(img1, img1.convert('L').getdata())
    pixels2 = rgba_map.get(img2, img2.convert('L').getdata())
    pixels = itertools.izip(pixels1, pixels2)
    diff = 0
    for px1, px2 in pixels:
        diff = diff + abs(px1-px2)
    pixel_count = 1.0 * img1.size[0] * img1.size[1]
    normalized_diff = diff / pixel_count / 255.0 * 100.0
    if normalized_diff <= 0.5: return True
    return False

def main(argv):
  codepoint_map_1 = {}
  codepoint_map_2 = {}
  glyph_to_codepoint_map_1 = {}
  glyph_to_codepoint_map_2 = {}

  with contextlib.closing(ttLib.TTFont(argv[1])) as ttf:
    font1_cbdt = read_cbdt(ttf)
    read_cmap12(ttf, glyph_to_codepoint_map_1, codepoint_map_1)
    read_gsub(ttf, glyph_to_codepoint_map_1, codepoint_map_1)
  with contextlib.closing(ttLib.TTFont(argv[2])) as ttf:
    font2_cbdt = read_cbdt(ttf)
    read_cmap12(ttf, glyph_to_codepoint_map_2, codepoint_map_2)
    read_gsub(ttf, glyph_to_codepoint_map_2, codepoint_map_2)

  glyphs1 = set(font1_cbdt.keys())
  glyphs2 = set(font2_cbdt.keys())

  codepoints_set1 = set(codepoint_map_1.keys())
  codepoints_set2 = set(codepoint_map_2.keys())

  if codepoints_set1 != codepoints_set2:
    print "Codepoints set has changed: : %s" % (codepoints_set1 ^ codepoints_set2)

  all_codepoints = set(codepoint_map_1.keys()).union(codepoint_map_2.keys())

  for key in all_codepoints:
    glyph1 = codepoint_map_1[key] if key in codepoint_map_1 else None
    glyph2 = codepoint_map_2[key] if key in codepoint_map_2 else None

    image1 = font1_cbdt[glyph1] if glyph1 and glyph1 in font1_cbdt else None
    image2 = font2_cbdt[glyph2] if glyph2 and glyph2 in font2_cbdt else None

    if not similar_img(image1, image2):
      print 'Glyph %s has different image' % key
      if image1:
        with open(os.path.join(argv[3], '%s_old.png' % key), 'w') as f:
            image1.save(f)
      if image2:
        with open(os.path.join(argv[3], '%s_new.png' % key), 'w') as f:
            image2.save(f)


def print_usage():
    """Prints how to use the script."""
    print("usage: old_font new_font output_dir")

if __name__ == '__main__':
   if len(sys.argv) < 3:
       print_usage()
       sys.exit(1)
   main(sys.argv)