How to find out if an font support an character?

[moi15moi]

How can I find out if an font support an character?

For example, I wanna know if this font.zip support the glyph ë.
In fontforge, I can clearly see that it support it.

I have try this, but it doesn't work:

from fontTools.ttLib.ttFont import TTFont

def is_glyph_supported(font: TTFont, glyph: str):
    if len(glyph) != 1:
        raise Exception("Glyph need to be 1 character.")


    for table in font["cmap"].tables:
        if ord(glyph) in table.cmap:
            return True

    return False

font = TTFont("test.ttf")
print(is_glyph_supported(font, "ë")) # it return me false when it should return true

I have also try this, but it also doesn't work:

from fontTools.ttLib.ttFont import TTFont
from fontTools.misc.encodingTools import getEncoding

def is_glyph_supported(font: TTFont, glyph: str):
    if len(glyph) != 1:
        raise Exception("Glyph need to be 1 character.")


    for table in font["cmap"].tables:
        if (glyph).encode(getEncoding(table.platformID, table.platEncID, table.language)) in table.cmap:
            return True

    return False

font = TTFont("test.ttf")
print(is_glyph_supported(font, "ë")) # it return me false when it should return true

[typoman]

You can get the character map this way:

from fontTools.ttLib import TTFont

f = TTFont(font_path)
cmap = f.getBestCmap()

[justvanrossum]

I want to know how to correct the codepoints in the cmap so that the character ë is well associated with the codepoint 0x91

When rendering, or when figuring out whether the font supports a certain (unicode) character, you do the following:

• Look for a unicode cmap subtable. If found, you're done (check if the code point exists in the cmap). This is not the case for this font because the font does not have a unicode cmap.
• Find the next best cmap, which in this case is a cmap subtable for MacRoman
• Now, if you want to render "ë", or want to know whether "ë" exists in this font, you will have to find the MacRoman code point for "ë". Which is 0x91.

So far so good.

(currently, it is associated with the codepoint 0x98).

No it is not, you've still got it backwards.

The character ë (Unicode U+00EB, MacRoman 0x91) is mapped to glyph id 98 (decimal), by the MacRoman cmap subtable.

If you use this font to render the glyph with glyph id 98 (decimal), you will see a shape that correctly represents the character ë.

If you look at this font with fonttools, you will notice that glyph id 98 (decimal) was assigned the name "adieresis". This name is incorrect, due to the post table being wrong.

• The cmap is correct
• The glyph shapes are correct
• The names are "wrong" because the post table is wrong.
• For rendering, or finding out whether a character exists in the font the glyph names are irrelevant
• The font works correctly despite the post table being wrong
• It just seems weird in fonttools, because it relies on a non-buggy post table to assign meaningful names
• Due to the buggy post table the names you see in fonttools for this buggy font are meaningless.

I really don't know how to explain it any clearer. I have now tried in 3, 4 different ways.

[justvanrossum]

• The glyphs inside a TTF are stored in an array in the glyf table
• Much simplified: font renderers find the glyph they want to render by looking up a character in the cmap. This gives them a glyph ID. The glyph ID is the index of the glyph into the glyphs array in the glyf table. They will render the glyph specified by that glyph ID.
• The post table has various ways to assign a name to each glyph ID (or none at all)
• So there often is a one-on-one mapping between glyph names and glyph IDs.
• Generally, as a font designer or engineer, it is much more pleasant to work with glyph names than with glyph IDs. The IDs differ per font, and you can not easily tell what the glyph may represent by looking at the glyph ID.
• Therefore, FontTools chooses to assign glyph names to each glyph ID, and uses them instead of glyph IDs, and it finds names by reading the post table
• Now, what if the post table contains an incorrect or weird glyph ID to glyph name mapping? Right: the names you see in FontTools now no longer make sense. This is what's happing in the font we're looking at.

[anthrotype]

Just's last two replies above should be "marked as answer".

[moi15moi]

Ok, I did not understood that the codepoints were already good, but it was only the name that wasn't.

I should have verified earlier that the glyph were already by creating an svg for each glyph and verify them:

from fontTools.ttLib.ttFont import TTFont
from fontTools.pens.svgPathPen import SVGPathPen
from fontTools.pens.transformPen import TransformPen

font = TTFont("test.ttf")

glyphSet = font.getGlyphSet()

for table in font["cmap"].tables:
    for codepoint, name in table.cmap.items():

        svgpen = SVGPathPen(glyphSet)
        pen= TransformPen(svgpen , (1, 0, 0, -1, 0, 750))
        glyphSet[name].draw(pen)
        path = svgpen.getCommands()

        with open(f"{hex(codepoint)}.svg", "w") as text_file:
            text_file.write('<?xml version="1.0" encoding="UTF-8"?>\n')
            text_file.write('<svg baseProfile="full" width="1500" height="1500" xmlns="http://www.w3.org/2000/svg">\n')
            text_file.write(f'<path fill="black" d="{path}" />\n')
            text_file.write('</svg>')

So, in brief, here is what I was looking for:

from fontTools.ttLib.ttFont import TTFont

def get_cmap_encoding(platformID, platEncID):
    encoding_map = {
        1: { # Mac
            0: 'mac_roman', # Need to verify if GDI has some exception with some langID
        },
        3: { # Microsoft
            0: 'utf_16_be',
            1: 'utf_16_be',
            2: 'shift_jis',
            3: 'gb2312',
            4: 'big5',
            5: 'euc_kr',
            6: 'johab',
            10: 'utf_16_be',
        },
    }

    return encoding_map.get(platformID, {}).get(platEncID, None)

def is_glyph_supported(font: TTFont, caracter: str):
    if len(caracter) != 1:
        raise Exception("Glyph need to be 1 character.")

    for table in font["cmap"].tables:
        cmap_encoding = get_cmap_encoding(table.platformID, table.platEncID)

        # Cmap isn't supported
        if cmap_encoding is None:
             continue
        
        if ord(caracter.encode(cmap_encoding)) in table.cmap:
            return True

    return False

font = TTFont("test.ttf")
print(is_glyph_supported(font, "ë"))