Fonttabelle mit Matplotlib zeichnen

Einführung

Matplotlib ist eine beliebte Datenvisualisierungsbibliothek in Python. Es bietet Schriftzeichenunterstützung über die FreeType-Bibliothek. In diesem Lab werden wir lernen, wie man eine Schriftzeichentabelle der ersten 255 Zeichen einer gegebenen Schrift mit Hilfe von Axes.table von Matplotlib zeichnet.

Tipps für die VM

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Drucken von Glyphen in einer Schrift

In diesem Schritt werden wir eine Funktion print_glyphs definieren, die alle Glyphen in einer gegebenen Schriftdatei auf die Standardeingabe ausgibt.

import os
import unicodedata
import matplotlib.font_manager as fm
from matplotlib.ft2font import FT2Font

def print_glyphs(path):
    """
    Druckt alle Glyphen in der gegebenen Schriftdatei auf die Standardeingabe aus.

    Parameter
    ----------
    path : str oder None
        Der Pfad zur Schriftdatei. Wenn None, wird die Standardschrift von Matplotlib verwendet.
    """
    if path is None:
        path = fm.findfont(fm.FontProperties())  ## Die Standardschrift.

    font = FT2Font(path)

    charmap = font.get_charmap()
    max_indices_len = len(str(max(charmap.values())))

    print("Die Schriftart enthält die folgenden Glyphen:")
    for char_code, glyph_index in charmap.items():
        char = chr(char_code)
        name = unicodedata.name(
                char,
                f"{char_code:#x} ({font.get_glyph_name(glyph_index)})")
        print(f"{glyph_index:>{max_indices_len}} {char} {name}")

Zeichnen einer Schrifttabelle

In diesem Schritt werden wir eine Funktion draw_font_table definieren, die eine Schrifttabelle der ersten 255 Zeichen der gegebenen Schrift zeichnet.

import os
from pathlib import Path
import unicodedata
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
from matplotlib.ft2font import FT2Font

def draw_font_table(path):
    """
    Zeichnet eine Schrifttabelle der ersten 255 Zeichen der gegebenen Schrift.

    Parameter
    ----------
    path : str oder None
        Der Pfad zur Schriftdatei. Wenn None, wird die Standardschrift von Matplotlib verwendet.
    """
    if path is None:
        path = fm.findfont(fm.FontProperties())  ## Die Standardschrift.

    font = FT2Font(path)

    ## Holt die Zeichenkarte der Schrift
    codes = font.get_charmap().items()

    ## Erstellt die Labels und Zellen der Tabelle
    labelc = [f"{i:X}" for i in range(16)]
    labelr = [f"{i:02X}" for i in range(0, 16*16, 16)]
    chars = [["" for c in range(16)] for r in range(16)]

    for char_code, glyph_index in codes:
        if char_code >= 256:
            continue
        row, col = divmod(char_code, 16)
        chars[row][col] = chr(char_code)

    ## Zeichnet die Tabelle mit Hilfe von Matplotlib's Axes.table
    fig, ax = plt.subplots(figsize=(8, 4))
    ax.set_title(os.path.basename(path))
    ax.set_axis_off()

    table = ax.table(
        cellText=chars,
        rowLabels=labelr,
        colLabels=labelc,
        rowColours=["palegreen"] * 16,
        colColours=["palegreen"] * 16,
        cellColours=[[".95" for c in range(16)] for r in range(16)],
        cellLoc='center',
        loc='upper left',
    )

    ## Setzt die Schrift der Tabellenzellen auf die Schrift des gegebenen Pfads
    for key, cell in table.get_celld().items():
        row, col = key
        if row > 0 and col > -1:  ## Achten Sie auf die eigenartige Indizierung der Tabelle...
            cell.set_text_props(font=Path(path))

    fig.tight_layout()
    plt.show()

Zeige die Schrifttabelle an

In diesem Schritt werden wir argparse verwenden, um den Pfad zur Schriftdatei aus den Befehlszeilenargumenten zu analysieren. Anschließend werden wir print_glyphs aufrufen, um alle Glyphen in der Schriftdatei auszugeben, und draw_font_table, um die Schrifttabelle der ersten 255 Zeichen der Schrift zu zeichnen.

if __name__ == "__main__":
    from argparse import ArgumentParser

    parser = ArgumentParser(description="Zeige eine Schrifttabelle an.")
    parser.add_argument("path", nargs="?", help="Pfad zur Schriftdatei.")
    parser.add_argument("--print-all", action="store_true",
                        help="Optional: Drucke alle Zeichen auf die Standardeingabe aus.")
    args = parser.parse_args()

    if args.print_all:
        print_glyphs(args.path)
    draw_font_table(args.path)

Zusammenfassung

In diesem Lab haben wir gelernt, wie man eine Schrifttabelle der ersten 255 Zeichen einer Schriftdatei mit Hilfe von Axes.table von Matplotlib zeichnet. Wir haben Funktionen definiert, um alle Glyphen in einer Schriftdatei auszugeben und die Schrifttabelle zu zeichnen. Wir haben auch argparse verwendet, um den Pfad zur Schriftdatei aus den Befehlszeilenargumenten zu analysieren.