| r""" |
| .. redirect-from:: /users/fonts |
| .. redirect-from:: /users/explain/fonts |
| |
| .. _fonts: |
| |
| Fonts in Matplotlib |
| =================== |
| |
| Matplotlib needs fonts to work with its text engine, some of which are shipped |
| alongside the installation. The default font is `DejaVu Sans |
| <https://dejavu-fonts.github.io>`_ which covers most European writing systems. |
| However, users can configure the default fonts, and provide their own custom |
| fonts. See :ref:`Customizing text properties <text_props>` for |
| details and :ref:`font-nonlatin` in particular for glyphs not supported by |
| DejaVu Sans. |
| |
| Matplotlib also provides an option to offload text rendering to a TeX engine |
| (``usetex=True``), see :ref:`Text rendering with LaTeX |
| <usetex>`. |
| |
| Fonts in PDF and PostScript |
| --------------------------- |
| |
| Fonts have a long (and sometimes incompatible) history in computing, leading to |
| different platforms supporting different types of fonts. In practice, |
| Matplotlib supports three font specifications (in addition to pdf 'core fonts', |
| which are explained later in the guide): |
| |
| .. list-table:: Type of Fonts |
| :header-rows: 1 |
| |
| * - Type 1 (PDF) |
| - Type 3 (PDF/PS) |
| - TrueType (PDF) |
| * - One of the oldest types, introduced by Adobe |
| - Similar to Type 1 in terms of introduction |
| - Newer than previous types, used commonly today, introduced by Apple |
| * - Restricted subset of PostScript, charstrings are in bytecode |
| - Full PostScript language, allows embedding arbitrary code |
| (in theory, even render fractals when rasterizing!) |
| - Include a virtual machine that can execute code! |
| * - These fonts support font hinting |
| - Do not support font hinting |
| - Hinting supported (virtual machine processes the "hints") |
| * - Non-subsetted through Matplotlib |
| - Subsetted via external module ttconv |
| - Subsetted via external module |
| `fontTools <https://github.com/fonttools/fonttools>`__ |
| |
| .. note:: |
| |
| Adobe disabled__ support for authoring with Type 1 fonts in January 2023. |
| |
| __ https://helpx.adobe.com/fonts/kb/postscript-type-1-fonts-end-of-support.html |
| |
| Other font specifications which Matplotlib supports: |
| |
| - Type 42 fonts (PS): |
| |
| - PostScript wrapper around TrueType fonts |
| - 42 is the `Answer to Life, the Universe, and Everything! |
| <https://en.wikipedia.org/wiki/Answer_to_Life,_the_Universe,_and_Everything>`_ |
| - Matplotlib uses the external library |
| `fontTools <https://github.com/fonttools/fonttools>`__ to subset these types of |
| fonts |
| |
| - OpenType fonts: |
| |
| - OpenType is a new standard for digital type fonts, developed jointly by |
| Adobe and Microsoft |
| - Generally contain a much larger character set! |
| - Limited support with Matplotlib |
| |
| Font subsetting |
| ~~~~~~~~~~~~~~~ |
| |
| The PDF and PostScript formats support embedding fonts in files, allowing the |
| display program to correctly render the text, independent of what fonts are |
| installed on the viewer's computer and without the need to pre-rasterize the text. |
| This ensures that if the output is zoomed or resized the text does not become |
| pixelated. However, embedding full fonts in the file can lead to large output |
| files, particularly with fonts with many glyphs such as those that support CJK |
| (Chinese/Japanese/Korean). |
| |
| The solution to this problem is to subset the fonts used in the document and |
| only embed the glyphs actually used. This gets both vector text and small |
| files sizes. Computing the subset of the font required and writing the new |
| (reduced) font are both complex problem and thus Matplotlib relies on |
| `fontTools <https://fonttools.readthedocs.io/en/latest/>`__ and a vendored fork |
| of ttconv. |
| |
| Currently Type 3, Type 42, and TrueType fonts are subsetted. Type 1 fonts are not. |
| |
| Core Fonts |
| ~~~~~~~~~~ |
| |
| In addition to the ability to embed fonts, as part of the `PostScript |
| <https://en.wikipedia.org/wiki/PostScript_fonts#Core_Font_Set>`_ and `PDF |
| specification |
| <https://docs.oracle.com/cd/E96927_01/TSG/FAQ/What%20are%20the%2014%20base%20fonts%20distributed%20with%20Acroba.html>`_ |
| there are 14 Core Fonts that compliant viewers must ensure are available. If |
| you restrict your document to only these fonts you do not have to embed any |
| font information in the document but still get vector text. |
| |
| This is especially helpful to generate *really lightweight* documents:: |
| |
| # trigger core fonts for PDF backend |
| plt.rcParams["pdf.use14corefonts"] = True |
| # trigger core fonts for PS backend |
| plt.rcParams["ps.useafm"] = True |
| |
| chars = "AFM ftw!" |
| fig, ax = plt.subplots() |
| ax.text(0.5, 0.5, chars) |
| |
| fig.savefig("AFM_PDF.pdf", format="pdf") |
| fig.savefig("AFM_PS.ps", format="ps") |
| |
| Fonts in SVG |
| ------------ |
| |
| Text can output to SVG in two ways controlled by :rc:`svg.fonttype`: |
| |
| - as a path (``'path'``) in the SVG |
| - as string in the SVG with font styling on the element (``'none'``) |
| |
| When saving via ``'path'`` Matplotlib will compute the path of the glyphs used |
| as vector paths and write those to the output. The advantage of doing so is |
| that the SVG will look the same on all computers independent of what fonts are |
| installed. However the text will not be editable after the fact. |
| In contrast, saving with ``'none'`` will result in smaller files and the |
| text will appear directly in the markup. However, the appearance may vary |
| based on the SVG viewer and what fonts are available. |
| |
| Fonts in Agg |
| ------------ |
| |
| To output text to raster formats via Agg, Matplotlib relies on `FreeType |
| <https://www.freetype.org/>`_. Because the exact rendering of the glyphs |
| changes between FreeType versions we pin to a specific version for our image |
| comparison tests. |
| |
| How Matplotlib selects fonts |
| ---------------------------- |
| |
| Internally, using a font in Matplotlib is a three step process: |
| |
| 1. a `.FontProperties` object is created (explicitly or implicitly) |
| 2. based on the `.FontProperties` object the methods on `.FontManager` are used |
| to select the closest "best" font Matplotlib is aware of (except for |
| ``'none'`` mode of SVG). |
| 3. the Python proxy for the font object is used by the backend code to render |
| the text -- the exact details depend on the backend via `.font_manager.get_font`. |
| |
| The algorithm to select the "best" font is a modified version of the algorithm |
| specified by the `CSS1 Specifications |
| <http://www.w3.org/TR/1998/REC-CSS2-19980512/>`_ which is used by web browsers. |
| This algorithm takes into account the font family name (e.g. "Arial", "Noto |
| Sans CJK", "Hack", ...), the size, style, and weight. In addition to family |
| names that map directly to fonts there are five "generic font family names" |
| (serif, monospace, fantasy, cursive, and sans-serif) that will internally be |
| mapped to any one of a set of fonts. |
| |
| Currently the public API for doing step 2 is `.FontManager.findfont` (and that |
| method on the global `.FontManager` instance is aliased at the module level as |
| `.font_manager.findfont`), which will only find a single font and return the absolute |
| path to the font on the filesystem. |
| |
| Font fallback |
| ------------- |
| |
| There is no font that covers the entire Unicode space thus it is possible for the |
| users to require a mix of glyphs that cannot be satisfied from a single font. |
| While it has been possible to use multiple fonts within a Figure, on distinct |
| `.Text` instances, it was not previous possible to use multiple fonts in the |
| same `.Text` instance (as a web browser does). As of Matplotlib 3.6 the Agg, |
| SVG, PDF, and PS backends will "fallback" through multiple fonts in a single |
| `.Text` instance: |
| |
| .. plot:: |
| :include-source: |
| :caption: The string "There are 几个汉字 in between!" rendered with 2 fonts. |
| |
| fig, ax = plt.subplots() |
| ax.text( |
| .5, .5, "There are 几个汉字 in between!", |
| family=['DejaVu Sans', 'Noto Sans CJK JP', 'Noto Sans TC'], |
| ha='center' |
| ) |
| |
| Internally this is implemented by setting The "font family" on |
| `.FontProperties` objects to a list of font families. A (currently) |
| private API extracts a list of paths to all of the fonts found and then |
| constructs a single `.ft2font.FT2Font` object that is aware of all of the fonts. |
| Each glyph of the string is rendered using the first font in the list that |
| contains that glyph. |
| |
| A majority of this work was done by Aitik Gupta supported by Google Summer of |
| Code 2021. |
| """ |
|
|
