Buckets:
ktongue/docker_container / simsite /venv /lib /python3.14 /site-packages /matplotlib /tests /test_ft2font.py
| import itertools | |
| import io | |
| from pathlib import Path | |
| import numpy as np | |
| import pytest | |
| import matplotlib as mpl | |
| from matplotlib import ft2font | |
| from matplotlib.testing.decorators import check_figures_equal | |
| import matplotlib.font_manager as fm | |
| import matplotlib.path as mpath | |
| import matplotlib.pyplot as plt | |
| def test_ft2image_draw_rect_filled(): | |
| width = 23 | |
| height = 42 | |
| for x0, y0, x1, y1 in itertools.product([1, 100], [2, 200], [4, 400], [8, 800]): | |
| im = ft2font.FT2Image(width, height) | |
| im.draw_rect_filled(x0, y0, x1, y1) | |
| a = np.asarray(im) | |
| assert a.dtype == np.uint8 | |
| assert a.shape == (height, width) | |
| if x0 == 100 or y0 == 200: | |
| # All the out-of-bounds starts should get automatically clipped. | |
| assert np.sum(a) == 0 | |
| else: | |
| # Otherwise, ends are clipped to the dimension, but are also _inclusive_. | |
| filled = (min(x1 + 1, width) - x0) * (min(y1 + 1, height) - y0) | |
| assert np.sum(a) == 255 * filled | |
| def test_ft2font_dejavu_attrs(): | |
| file = fm.findfont('DejaVu Sans') | |
| font = ft2font.FT2Font(file) | |
| assert font.fname == file | |
| # Names extracted from FontForge: Font Information → PS Names tab. | |
| assert font.postscript_name == 'DejaVuSans' | |
| assert font.family_name == 'DejaVu Sans' | |
| assert font.style_name == 'Book' | |
| assert font.num_faces == 1 # Single TTF. | |
| assert font.num_named_instances == 0 # Not a variable font. | |
| assert font.num_glyphs == 6241 # From compact encoding view in FontForge. | |
| assert font.num_fixed_sizes == 0 # All glyphs are scalable. | |
| assert font.num_charmaps == 5 | |
| # Other internal flags are set, so only check the ones we're allowed to test. | |
| expected_flags = (ft2font.FaceFlags.SCALABLE | ft2font.FaceFlags.SFNT | | |
| ft2font.FaceFlags.HORIZONTAL | ft2font.FaceFlags.KERNING | | |
| ft2font.FaceFlags.GLYPH_NAMES) | |
| assert expected_flags in font.face_flags | |
| assert font.style_flags == ft2font.StyleFlags.NORMAL | |
| assert font.scalable | |
| # From FontForge: Font Information → General tab → entry name below. | |
| assert font.units_per_EM == 2048 # Em Size. | |
| assert font.underline_position == -175 # Underline position. | |
| assert font.underline_thickness == 90 # Underline height. | |
| # From FontForge: Font Information → OS/2 tab → Metrics tab → entry name below. | |
| assert font.ascender == 1901 # HHead Ascent. | |
| assert font.descender == -483 # HHead Descent. | |
| # Unconfirmed values. | |
| assert font.height == 2384 | |
| assert font.max_advance_width == 3838 | |
| assert font.max_advance_height == 2384 | |
| assert font.bbox == (-2090, -948, 3673, 2524) | |
| def test_ft2font_cm_attrs(): | |
| file = fm.findfont('cmtt10') | |
| font = ft2font.FT2Font(file) | |
| assert font.fname == file | |
| # Names extracted from FontForge: Font Information → PS Names tab. | |
| assert font.postscript_name == 'Cmtt10' | |
| assert font.family_name == 'cmtt10' | |
| assert font.style_name == 'Regular' | |
| assert font.num_faces == 1 # Single TTF. | |
| assert font.num_named_instances == 0 # Not a variable font. | |
| assert font.num_glyphs == 133 # From compact encoding view in FontForge. | |
| assert font.num_fixed_sizes == 0 # All glyphs are scalable. | |
| assert font.num_charmaps == 2 | |
| # Other internal flags are set, so only check the ones we're allowed to test. | |
| expected_flags = (ft2font.FaceFlags.SCALABLE | ft2font.FaceFlags.SFNT | | |
| ft2font.FaceFlags.HORIZONTAL | ft2font.FaceFlags.GLYPH_NAMES) | |
| assert expected_flags in font.face_flags | |
| assert font.style_flags == ft2font.StyleFlags.NORMAL | |
| assert font.scalable | |
| # From FontForge: Font Information → General tab → entry name below. | |
| assert font.units_per_EM == 2048 # Em Size. | |
| assert font.underline_position == -143 # Underline position. | |
| assert font.underline_thickness == 20 # Underline height. | |
| # From FontForge: Font Information → OS/2 tab → Metrics tab → entry name below. | |
| assert font.ascender == 1276 # HHead Ascent. | |
| assert font.descender == -489 # HHead Descent. | |
| # Unconfirmed values. | |
| assert font.height == 1765 | |
| assert font.max_advance_width == 1536 | |
| assert font.max_advance_height == 1765 | |
| assert font.bbox == (-12, -477, 1280, 1430) | |
| def test_ft2font_stix_bold_attrs(): | |
| file = fm.findfont('STIXSizeTwoSym:bold') | |
| font = ft2font.FT2Font(file) | |
| assert font.fname == file | |
| # Names extracted from FontForge: Font Information → PS Names tab. | |
| assert font.postscript_name == 'STIXSizeTwoSym-Bold' | |
| assert font.family_name == 'STIXSizeTwoSym' | |
| assert font.style_name == 'Bold' | |
| assert font.num_faces == 1 # Single TTF. | |
| assert font.num_named_instances == 0 # Not a variable font. | |
| assert font.num_glyphs == 20 # From compact encoding view in FontForge. | |
| assert font.num_fixed_sizes == 0 # All glyphs are scalable. | |
| assert font.num_charmaps == 3 | |
| # Other internal flags are set, so only check the ones we're allowed to test. | |
| expected_flags = (ft2font.FaceFlags.SCALABLE | ft2font.FaceFlags.SFNT | | |
| ft2font.FaceFlags.HORIZONTAL | ft2font.FaceFlags.GLYPH_NAMES) | |
| assert expected_flags in font.face_flags | |
| assert font.style_flags == ft2font.StyleFlags.BOLD | |
| assert font.scalable | |
| # From FontForge: Font Information → General tab → entry name below. | |
| assert font.units_per_EM == 1000 # Em Size. | |
| assert font.underline_position == -133 # Underline position. | |
| assert font.underline_thickness == 20 # Underline height. | |
| # From FontForge: Font Information → OS/2 tab → Metrics tab → entry name below. | |
| assert font.ascender == 2095 # HHead Ascent. | |
| assert font.descender == -404 # HHead Descent. | |
| # Unconfirmed values. | |
| assert font.height == 2499 | |
| assert font.max_advance_width == 1130 | |
| assert font.max_advance_height == 2499 | |
| assert font.bbox == (4, -355, 1185, 2095) | |
| def test_ft2font_invalid_args(tmp_path): | |
| # filename argument. | |
| with pytest.raises(TypeError, match='to a font file or a binary-mode file object'): | |
| ft2font.FT2Font(None) | |
| with pytest.raises(TypeError, match='to a font file or a binary-mode file object'): | |
| ft2font.FT2Font(object()) # Not bytes or string, and has no read() method. | |
| file = tmp_path / 'invalid-font.ttf' | |
| file.write_text('This is not a valid font file.') | |
| with (pytest.raises(TypeError, match='to a font file or a binary-mode file object'), | |
| file.open('rt') as fd): | |
| ft2font.FT2Font(fd) | |
| with (pytest.raises(TypeError, match='to a font file or a binary-mode file object'), | |
| file.open('wt') as fd): | |
| ft2font.FT2Font(fd) | |
| with (pytest.raises(TypeError, match='to a font file or a binary-mode file object'), | |
| file.open('wb') as fd): | |
| ft2font.FT2Font(fd) | |
| file = fm.findfont('DejaVu Sans') | |
| # hinting_factor argument. | |
| with pytest.raises(TypeError, match='incompatible constructor arguments'): | |
| ft2font.FT2Font(file, 1.3) | |
| with pytest.raises(ValueError, match='hinting_factor must be greater than 0'): | |
| ft2font.FT2Font(file, 0) | |
| with pytest.raises(TypeError, match='incompatible constructor arguments'): | |
| # failing to be a list will fail before the 0 | |
| ft2font.FT2Font(file, _fallback_list=(0,)) # type: ignore[arg-type] | |
| with pytest.raises(TypeError, match='incompatible constructor arguments'): | |
| ft2font.FT2Font(file, _fallback_list=[0]) # type: ignore[list-item] | |
| # kerning_factor argument. | |
| with pytest.raises(TypeError, match='incompatible constructor arguments'): | |
| ft2font.FT2Font(file, _kerning_factor=1.3) | |
| def test_ft2font_clear(): | |
| file = fm.findfont('DejaVu Sans') | |
| font = ft2font.FT2Font(file) | |
| assert font.get_num_glyphs() == 0 | |
| assert font.get_width_height() == (0, 0) | |
| assert font.get_bitmap_offset() == (0, 0) | |
| font.set_text('ABabCDcd') | |
| assert font.get_num_glyphs() == 8 | |
| assert font.get_width_height() != (0, 0) | |
| assert font.get_bitmap_offset() != (0, 0) | |
| font.clear() | |
| assert font.get_num_glyphs() == 0 | |
| assert font.get_width_height() == (0, 0) | |
| assert font.get_bitmap_offset() == (0, 0) | |
| def test_ft2font_set_size(): | |
| file = fm.findfont('DejaVu Sans') | |
| # Default is 12pt @ 72 dpi. | |
| font = ft2font.FT2Font(file, hinting_factor=1, _kerning_factor=1) | |
| font.set_text('ABabCDcd') | |
| orig = font.get_width_height() | |
| font.set_size(24, 72) | |
| font.set_text('ABabCDcd') | |
| assert font.get_width_height() == tuple(pytest.approx(2 * x, 1e-1) for x in orig) | |
| font.set_size(12, 144) | |
| font.set_text('ABabCDcd') | |
| assert font.get_width_height() == tuple(pytest.approx(2 * x, 1e-1) for x in orig) | |
| def test_ft2font_charmaps(): | |
| def enc(name): | |
| # We don't expose the encoding enum from FreeType, but can generate it here. | |
| # For DejaVu, there are 5 charmaps, but only 2 have enum entries in FreeType. | |
| e = 0 | |
| for x in name: | |
| e <<= 8 | |
| e += ord(x) | |
| return e | |
| file = fm.findfont('DejaVu Sans') | |
| font = ft2font.FT2Font(file) | |
| assert font.num_charmaps == 5 | |
| # Unicode. | |
| font.select_charmap(enc('unic')) | |
| unic = font.get_charmap() | |
| font.set_charmap(0) # Unicode platform, Unicode BMP only. | |
| after = font.get_charmap() | |
| assert len(after) <= len(unic) | |
| for chr, glyph in after.items(): | |
| assert unic[chr] == glyph == font.get_char_index(chr) | |
| font.set_charmap(1) # Unicode platform, modern subtable. | |
| after = font.get_charmap() | |
| assert unic == after | |
| font.set_charmap(3) # Windows platform, Unicode BMP only. | |
| after = font.get_charmap() | |
| assert len(after) <= len(unic) | |
| for chr, glyph in after.items(): | |
| assert unic[chr] == glyph == font.get_char_index(chr) | |
| font.set_charmap(4) # Windows platform, Unicode full repertoire, modern subtable. | |
| after = font.get_charmap() | |
| assert unic == after | |
| # This is just a random sample from FontForge. | |
| glyph_names = { | |
| 'non-existent-glyph-name': 0, | |
| 'plusminus': 115, | |
| 'Racute': 278, | |
| 'perthousand': 2834, | |
| 'seveneighths': 3057, | |
| 'triagup': 3721, | |
| 'uni01D3': 405, | |
| 'uni0417': 939, | |
| 'uni2A02': 4464, | |
| 'u1D305': 5410, | |
| 'u1F0A1': 5784, | |
| } | |
| for name, index in glyph_names.items(): | |
| assert font.get_name_index(name) == index | |
| if name == 'non-existent-glyph-name': | |
| name = '.notdef' | |
| # This doesn't always apply, but it does for DejaVu Sans. | |
| assert font.get_glyph_name(index) == name | |
| # Apple Roman. | |
| font.select_charmap(enc('armn')) | |
| armn = font.get_charmap() | |
| font.set_charmap(2) # Macintosh platform, Roman. | |
| after = font.get_charmap() | |
| assert armn == after | |
| assert len(armn) <= 256 # 8-bit encoding. | |
| # The first 128 characters of Apple Roman match ASCII, which also matches Unicode. | |
| for o in range(1, 128): | |
| if o not in armn or o not in unic: | |
| continue | |
| assert unic[o] == armn[o] | |
| # Check a couple things outside the ASCII set that are different in each charset. | |
| examples = [ | |
| # (Unicode, Macintosh) | |
| (0x2020, 0xA0), # Dagger. | |
| (0x00B0, 0xA1), # Degree symbol. | |
| (0x00A3, 0xA3), # Pound sign. | |
| (0x00A7, 0xA4), # Section sign. | |
| (0x00B6, 0xA6), # Pilcrow. | |
| (0x221E, 0xB0), # Infinity symbol. | |
| ] | |
| for u, m in examples: | |
| # Though the encoding is different, the glyph should be the same. | |
| assert unic[u] == armn[m] | |
| _expected_sfnt_names = { | |
| 'DejaVu Sans': { | |
| 0: 'Copyright (c) 2003 by Bitstream, Inc. All Rights Reserved.\n' | |
| 'Copyright (c) 2006 by Tavmjong Bah. All Rights Reserved.\n' | |
| 'DejaVu changes are in public domain\n', | |
| 1: 'DejaVu Sans', | |
| 2: 'Book', | |
| 3: 'DejaVu Sans', | |
| 4: 'DejaVu Sans', | |
| 5: 'Version 2.35', | |
| 6: 'DejaVuSans', | |
| 8: 'DejaVu fonts team', | |
| 11: 'http://dejavu.sourceforge.net', | |
| 13: 'Fonts are (c) Bitstream (see below). ' | |
| 'DejaVu changes are in public domain. ' | |
| '''Glyphs imported from Arev fonts are (c) Tavmjung Bah (see below) | |
| Bitstream Vera Fonts Copyright | |
| ------------------------------ | |
| Copyright (c) 2003 by Bitstream, Inc. All Rights Reserved. Bitstream Vera is | |
| a trademark of Bitstream, Inc. | |
| Permission is hereby granted, free of charge, to any person obtaining a copy | |
| of the fonts accompanying this license ("Fonts") and associated | |
| documentation files (the "Font Software"), to reproduce and distribute the | |
| Font Software, including without limitation the rights to use, copy, merge, | |
| publish, distribute, and/or sell copies of the Font Software, and to permit | |
| persons to whom the Font Software is furnished to do so, subject to the | |
| following conditions: | |
| The above copyright and trademark notices and this permission notice shall | |
| be included in all copies of one or more of the Font Software typefaces. | |
| The Font Software may be modified, altered, or added to, and in particular | |
| the designs of glyphs or characters in the Fonts may be modified and | |
| additional glyphs or characters may be added to the Fonts, only if the fonts | |
| are renamed to names not containing either the words "Bitstream" or the word | |
| "Vera". | |
| This License becomes null and void to the extent applicable to Fonts or Font | |
| Software that has been modified and is distributed under the "Bitstream | |
| Vera" names. | |
| The Font Software may be sold as part of a larger software package but no | |
| copy of one or more of the Font Software typefaces may be sold by itself. | |
| THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
| OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, | |
| FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, | |
| TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL BITSTREAM OR THE GNOME | |
| FOUNDATION BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING | |
| ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, | |
| WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF | |
| THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE | |
| FONT SOFTWARE. | |
| Except as contained in this notice, the names of Gnome, the Gnome | |
| Foundation, and Bitstream Inc., shall not be used in advertising or | |
| otherwise to promote the sale, use or other dealings in this Font Software | |
| without prior written authorization from the Gnome Foundation or Bitstream | |
| Inc., respectively. For further information, contact: fonts at gnome dot | |
| org. ''' ''' | |
| Arev Fonts Copyright | |
| ------------------------------ | |
| Copyright (c) 2006 by Tavmjong Bah. All Rights Reserved. | |
| Permission is hereby granted, free of charge, to any person obtaining | |
| a copy of the fonts accompanying this license ("Fonts") and | |
| associated documentation files (the "Font Software"), to reproduce | |
| and distribute the modifications to the Bitstream Vera Font Software, | |
| including without limitation the rights to use, copy, merge, publish, | |
| distribute, and/or sell copies of the Font Software, and to permit | |
| persons to whom the Font Software is furnished to do so, subject to | |
| the following conditions: | |
| The above copyright and trademark notices and this permission notice | |
| shall be included in all copies of one or more of the Font Software | |
| typefaces. | |
| The Font Software may be modified, altered, or added to, and in | |
| particular the designs of glyphs or characters in the Fonts may be | |
| modified and additional glyphs or characters may be added to the | |
| Fonts, only if the fonts are renamed to names not containing either | |
| the words "Tavmjong Bah" or the word "Arev". | |
| This License becomes null and void to the extent applicable to Fonts | |
| or Font Software that has been modified and is distributed under the ''' ''' | |
| "Tavmjong Bah Arev" names. | |
| The Font Software may be sold as part of a larger software package but | |
| no copy of one or more of the Font Software typefaces may be sold by | |
| itself. | |
| THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
| EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF | |
| MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT | |
| OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL | |
| TAVMJONG BAH BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, | |
| INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL | |
| DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | |
| FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM | |
| OTHER DEALINGS IN THE FONT SOFTWARE. | |
| Except as contained in this notice, the name of Tavmjong Bah shall not | |
| be used in advertising or otherwise to promote the sale, use or other | |
| dealings in this Font Software without prior written authorization | |
| from Tavmjong Bah. For further information, contact: tavmjong @ free | |
| . fr.''', | |
| 14: 'http://dejavu.sourceforge.net/wiki/index.php/License', | |
| 16: 'DejaVu Sans', | |
| 17: 'Book', | |
| }, | |
| 'cmtt10': { | |
| 0: 'Copyright (C) 1994, Basil K. Malyshev. All Rights Reserved.' | |
| '012BaKoMa Fonts Collection, Level-B.', | |
| 1: 'cmtt10', | |
| 2: 'Regular', | |
| 3: 'FontMonger:cmtt10', | |
| 4: 'cmtt10', | |
| 5: '1.1/12-Nov-94', | |
| 6: 'Cmtt10', | |
| }, | |
| 'STIXSizeTwoSym:bold': { | |
| 0: 'Copyright (c) 2001-2010 by the STI Pub Companies, consisting of the ' | |
| 'American Chemical Society, the American Institute of Physics, the American ' | |
| 'Mathematical Society, the American Physical Society, Elsevier, Inc., and ' | |
| 'The Institute of Electrical and Electronic Engineers, Inc. Portions ' | |
| 'copyright (c) 1998-2003 by MicroPress, Inc. Portions copyright (c) 1990 by ' | |
| 'Elsevier, Inc. All rights reserved.', | |
| 1: 'STIXSizeTwoSym', | |
| 2: 'Bold', | |
| 3: 'FontMaster:STIXSizeTwoSym-Bold:1.0.0', | |
| 4: 'STIXSizeTwoSym-Bold', | |
| 5: 'Version 1.0.0', | |
| 6: 'STIXSizeTwoSym-Bold', | |
| 7: 'STIX Fonts(TM) is a trademark of The Institute of Electrical and ' | |
| 'Electronics Engineers, Inc.', | |
| 9: 'MicroPress Inc., with final additions and corrections provided by Coen ' | |
| 'Hoffman, Elsevier (retired)', | |
| 10: 'Arie de Ruiter, who in 1995 was Head of Information Technology ' | |
| 'Development at Elsevier Science, made a proposal to the STI Pub group, an ' | |
| 'informal group of publishers consisting of representatives from the ' | |
| 'American Chemical Society (ACS), American Institute of Physics (AIP), ' | |
| 'American Mathematical Society (AMS), American Physical Society (APS), ' | |
| 'Elsevier, and Institute of Electrical and Electronics Engineers (IEEE). ' | |
| 'De Ruiter encouraged the members to consider development of a series of ' | |
| 'Web fonts, which he proposed should be called the Scientific and ' | |
| 'Technical Information eXchange, or STIX, Fonts. All STI Pub member ' | |
| 'organizations enthusiastically endorsed this proposal, and the STI Pub ' | |
| 'group agreed to embark on what has become a twelve-year project. The goal ' | |
| 'of the project was to identify all alphabetic, symbolic, and other ' | |
| 'special characters used in any facet of scientific publishing and to ' | |
| 'create a set of Unicode-based fonts that would be distributed free to ' | |
| 'every scientist, student, and other interested party worldwide. The fonts ' | |
| 'would be consistent with the emerging Unicode standard, and would permit ' | |
| 'universal representation of every character. With the release of the STIX ' | |
| "fonts, de Ruiter's vision has been realized.", | |
| 11: 'http://www.stixfonts.org', | |
| 12: 'http://www.micropress-inc.com', | |
| 13: 'As a condition for receiving these fonts at no charge, each person ' | |
| 'downloading the fonts must agree to some simple license terms. The ' | |
| 'license is based on the SIL Open Font License ' | |
| '<http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=OFL>. The ' | |
| 'SIL License is a free and open source license specifically designed for ' | |
| 'fonts and related software. The basic terms are that the recipient will ' | |
| 'not remove the copyright and trademark statements from the fonts and ' | |
| 'that, if the person decides to create a derivative work based on the STIX ' | |
| 'Fonts but incorporating some changes or enhancements, the derivative work ' | |
| '("Modified Version") will carry a different name. The copyright and ' | |
| 'trademark restrictions are part of the agreement between the STI Pub ' | |
| 'companies and the typeface designer. The "renaming" restriction results ' | |
| 'from the desire of the STI Pub companies to assure that the STIX Fonts ' | |
| 'will continue to function in a predictable fashion for all that use them. ' | |
| 'No copy of one or more of the individual Font typefaces that form the ' | |
| 'STIX Fonts(TM) set may be sold by itself, but other than this one ' | |
| 'restriction, licensees are free to sell the fonts either separately or as ' | |
| 'part of a package that combines other software or fonts with this font ' | |
| 'set.', | |
| 14: 'http://www.stixfonts.org/user_license.html', | |
| }, | |
| } | |
| def test_ft2font_get_sfnt(font_name, expected): | |
| file = fm.findfont(font_name) | |
| font = ft2font.FT2Font(file) | |
| sfnt = font.get_sfnt() | |
| for name, value in expected.items(): | |
| # Macintosh, Unicode 1.0, English, name. | |
| assert sfnt.pop((1, 0, 0, name)) == value.encode('ascii') | |
| # Microsoft, Unicode, English United States, name. | |
| assert sfnt.pop((3, 1, 1033, name)) == value.encode('utf-16be') | |
| assert sfnt == {} | |
| _expected_sfnt_tables = { | |
| 'DejaVu Sans': { | |
| 'invalid': None, | |
| 'head': { | |
| 'version': (1, 0), | |
| 'fontRevision': (2, 22937), | |
| 'checkSumAdjustment': -175678572, | |
| 'magicNumber': 0x5F0F3CF5, | |
| 'flags': 31, | |
| 'unitsPerEm': 2048, | |
| 'created': (0, 3514699492), 'modified': (0, 3514699492), | |
| 'xMin': -2090, 'yMin': -948, 'xMax': 3673, 'yMax': 2524, | |
| 'macStyle': 0, | |
| 'lowestRecPPEM': 8, | |
| 'fontDirectionHint': 0, | |
| 'indexToLocFormat': 1, | |
| 'glyphDataFormat': 0, | |
| }, | |
| 'maxp': { | |
| 'version': (1, 0), | |
| 'numGlyphs': 6241, | |
| 'maxPoints': 852, 'maxComponentPoints': 104, 'maxTwilightPoints': 16, | |
| 'maxContours': 43, 'maxComponentContours': 12, | |
| 'maxZones': 2, | |
| 'maxStorage': 153, | |
| 'maxFunctionDefs': 64, | |
| 'maxInstructionDefs': 0, | |
| 'maxStackElements': 1045, | |
| 'maxSizeOfInstructions': 534, | |
| 'maxComponentElements': 8, | |
| 'maxComponentDepth': 4, | |
| }, | |
| 'OS/2': { | |
| 'version': 1, | |
| 'xAvgCharWidth': 1038, | |
| 'usWeightClass': 400, 'usWidthClass': 5, | |
| 'fsType': 0, | |
| 'ySubscriptXSize': 1331, 'ySubscriptYSize': 1433, | |
| 'ySubscriptXOffset': 0, 'ySubscriptYOffset': 286, | |
| 'ySuperscriptXSize': 1331, 'ySuperscriptYSize': 1433, | |
| 'ySuperscriptXOffset': 0, 'ySuperscriptYOffset': 983, | |
| 'yStrikeoutSize': 102, 'yStrikeoutPosition': 530, | |
| 'sFamilyClass': 0, | |
| 'panose': b'\x02\x0b\x06\x03\x03\x08\x04\x02\x02\x04', | |
| 'ulCharRange': (3875565311, 3523280383, 170156073, 67117068), | |
| 'achVendID': b'PfEd', | |
| 'fsSelection': 64, 'fsFirstCharIndex': 32, 'fsLastCharIndex': 65535, | |
| }, | |
| 'hhea': { | |
| 'version': (1, 0), | |
| 'ascent': 1901, 'descent': -483, 'lineGap': 0, | |
| 'advanceWidthMax': 3838, | |
| 'minLeftBearing': -2090, 'minRightBearing': -1455, | |
| 'xMaxExtent': 3673, | |
| 'caretSlopeRise': 1, 'caretSlopeRun': 0, 'caretOffset': 0, | |
| 'metricDataFormat': 0, 'numOfLongHorMetrics': 6226, | |
| }, | |
| 'vhea': None, | |
| 'post': { | |
| 'format': (2, 0), | |
| 'isFixedPitch': 0, 'italicAngle': (0, 0), | |
| 'underlinePosition': -130, 'underlineThickness': 90, | |
| 'minMemType42': 0, 'maxMemType42': 0, | |
| 'minMemType1': 0, 'maxMemType1': 0, | |
| }, | |
| 'pclt': None, | |
| }, | |
| 'cmtt10': { | |
| 'invalid': None, | |
| 'head': { | |
| 'version': (1, 0), | |
| 'fontRevision': (1, 0), | |
| 'checkSumAdjustment': 555110277, | |
| 'magicNumber': 0x5F0F3CF5, | |
| 'flags': 3, | |
| 'unitsPerEm': 2048, | |
| 'created': (0, 0), 'modified': (0, 0), | |
| 'xMin': -12, 'yMin': -477, 'xMax': 1280, 'yMax': 1430, | |
| 'macStyle': 0, | |
| 'lowestRecPPEM': 6, | |
| 'fontDirectionHint': 2, | |
| 'indexToLocFormat': 1, | |
| 'glyphDataFormat': 0, | |
| }, | |
| 'maxp': { | |
| 'version': (1, 0), | |
| 'numGlyphs': 133, | |
| 'maxPoints': 94, 'maxComponentPoints': 0, 'maxTwilightPoints': 12, | |
| 'maxContours': 5, 'maxComponentContours': 0, | |
| 'maxZones': 2, | |
| 'maxStorage': 6, | |
| 'maxFunctionDefs': 64, | |
| 'maxInstructionDefs': 0, | |
| 'maxStackElements': 200, | |
| 'maxSizeOfInstructions': 100, | |
| 'maxComponentElements': 4, | |
| 'maxComponentDepth': 1, | |
| }, | |
| 'OS/2': { | |
| 'version': 0, | |
| 'xAvgCharWidth': 1075, | |
| 'usWeightClass': 400, 'usWidthClass': 5, | |
| 'fsType': 0, | |
| 'ySubscriptXSize': 410, 'ySubscriptYSize': 369, | |
| 'ySubscriptXOffset': 0, 'ySubscriptYOffset': -469, | |
| 'ySuperscriptXSize': 410, 'ySuperscriptYSize': 369, | |
| 'ySuperscriptXOffset': 0, 'ySuperscriptYOffset': 1090, | |
| 'yStrikeoutSize': 102, 'yStrikeoutPosition': 530, | |
| 'sFamilyClass': 0, | |
| 'panose': b'\x02\x0b\x05\x00\x00\x00\x00\x00\x00\x00', | |
| 'ulCharRange': (0, 0, 0, 0), | |
| 'achVendID': b'\x00\x00\x00\x00', | |
| 'fsSelection': 64, 'fsFirstCharIndex': 32, 'fsLastCharIndex': 9835, | |
| }, | |
| 'hhea': { | |
| 'version': (1, 0), | |
| 'ascent': 1276, 'descent': -489, 'lineGap': 0, | |
| 'advanceWidthMax': 1536, | |
| 'minLeftBearing': -12, 'minRightBearing': -29, | |
| 'xMaxExtent': 1280, | |
| 'caretSlopeRise': 1, 'caretSlopeRun': 0, 'caretOffset': 0, | |
| 'metricDataFormat': 0, 'numOfLongHorMetrics': 133, | |
| }, | |
| 'vhea': None, | |
| 'post': { | |
| 'format': (2, 0), | |
| 'isFixedPitch': 0, 'italicAngle': (0, 0), | |
| 'underlinePosition': -133, 'underlineThickness': 20, | |
| 'minMemType42': 0, 'maxMemType42': 0, | |
| 'minMemType1': 0, 'maxMemType1': 0, | |
| }, | |
| 'pclt': { | |
| 'version': (1, 0), | |
| 'fontNumber': 2147483648, | |
| 'pitch': 1075, | |
| 'xHeight': 905, | |
| 'style': 0, | |
| 'typeFamily': 0, | |
| 'capHeight': 1276, | |
| 'symbolSet': 0, | |
| 'typeFace': b'cmtt10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00', | |
| 'characterComplement': b'\xff\xff\xff\xff7\xff\xff\xfe', | |
| 'strokeWeight': 0, | |
| 'widthType': -5, | |
| 'serifStyle': 64, | |
| }, | |
| }, | |
| 'STIXSizeTwoSym:bold': { | |
| 'invalid': None, | |
| 'head': { | |
| 'version': (1, 0), | |
| 'fontRevision': (1, 0), | |
| 'checkSumAdjustment': 1803408080, | |
| 'magicNumber': 0x5F0F3CF5, | |
| 'flags': 11, | |
| 'unitsPerEm': 1000, | |
| 'created': (0, 3359035786), 'modified': (0, 3359035786), | |
| 'xMin': 4, 'yMin': -355, 'xMax': 1185, 'yMax': 2095, | |
| 'macStyle': 1, | |
| 'lowestRecPPEM': 8, | |
| 'fontDirectionHint': 2, | |
| 'indexToLocFormat': 0, | |
| 'glyphDataFormat': 0, | |
| }, | |
| 'maxp': { | |
| 'version': (1, 0), | |
| 'numGlyphs': 20, | |
| 'maxPoints': 37, 'maxComponentPoints': 0, 'maxTwilightPoints': 0, | |
| 'maxContours': 1, 'maxComponentContours': 0, | |
| 'maxZones': 2, | |
| 'maxStorage': 1, | |
| 'maxFunctionDefs': 64, | |
| 'maxInstructionDefs': 0, | |
| 'maxStackElements': 64, | |
| 'maxSizeOfInstructions': 0, | |
| 'maxComponentElements': 0, | |
| 'maxComponentDepth': 0, | |
| }, | |
| 'OS/2': { | |
| 'version': 2, | |
| 'xAvgCharWidth': 598, | |
| 'usWeightClass': 700, 'usWidthClass': 5, | |
| 'fsType': 0, | |
| 'ySubscriptXSize': 500, 'ySubscriptYSize': 500, | |
| 'ySubscriptXOffset': 0, 'ySubscriptYOffset': 250, | |
| 'ySuperscriptXSize': 500, 'ySuperscriptYSize': 500, | |
| 'ySuperscriptXOffset': 0, 'ySuperscriptYOffset': 500, | |
| 'yStrikeoutSize': 20, 'yStrikeoutPosition': 1037, | |
| 'sFamilyClass': 0, | |
| 'panose': b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00', | |
| 'ulCharRange': (3, 192, 0, 0), | |
| 'achVendID': b'STIX', | |
| 'fsSelection': 32, 'fsFirstCharIndex': 32, 'fsLastCharIndex': 10217, | |
| }, | |
| 'hhea': { | |
| 'version': (1, 0), | |
| 'ascent': 2095, 'descent': -404, 'lineGap': 0, | |
| 'advanceWidthMax': 1130, | |
| 'minLeftBearing': 0, 'minRightBearing': -55, | |
| 'xMaxExtent': 1185, | |
| 'caretSlopeRise': 1, 'caretSlopeRun': 0, 'caretOffset': 0, | |
| 'metricDataFormat': 0, 'numOfLongHorMetrics': 19, | |
| }, | |
| 'vhea': None, | |
| 'post': { | |
| 'format': (2, 0), | |
| 'isFixedPitch': 0, 'italicAngle': (0, 0), | |
| 'underlinePosition': -123, 'underlineThickness': 20, | |
| 'minMemType42': 0, 'maxMemType42': 0, | |
| 'minMemType1': 0, 'maxMemType1': 0, | |
| }, | |
| 'pclt': None, | |
| }, | |
| } | |
| def test_ft2font_get_sfnt_table(font_name, header): | |
| file = fm.findfont(font_name) | |
| font = ft2font.FT2Font(file) | |
| assert font.get_sfnt_table(header) == _expected_sfnt_tables[font_name][header] | |
| def test_ft2font_get_kerning(left, right, unscaled, unfitted, default): | |
| file = fm.findfont('DejaVu Sans') | |
| # With unscaled, these settings should produce exact values found in FontForge. | |
| font = ft2font.FT2Font(file, hinting_factor=1, _kerning_factor=0) | |
| font.set_size(100, 100) | |
| assert font.get_kerning(font.get_char_index(ord(left)), | |
| font.get_char_index(ord(right)), | |
| ft2font.Kerning.UNSCALED) == unscaled | |
| assert font.get_kerning(font.get_char_index(ord(left)), | |
| font.get_char_index(ord(right)), | |
| ft2font.Kerning.UNFITTED) == unfitted | |
| assert font.get_kerning(font.get_char_index(ord(left)), | |
| font.get_char_index(ord(right)), | |
| ft2font.Kerning.DEFAULT) == default | |
| with pytest.warns(mpl.MatplotlibDeprecationWarning, | |
| match='Use Kerning.UNSCALED instead'): | |
| k = ft2font.KERNING_UNSCALED | |
| with pytest.warns(mpl.MatplotlibDeprecationWarning, | |
| match='Use Kerning enum values instead'): | |
| assert font.get_kerning(font.get_char_index(ord(left)), | |
| font.get_char_index(ord(right)), | |
| int(k)) == unscaled | |
| with pytest.warns(mpl.MatplotlibDeprecationWarning, | |
| match='Use Kerning.UNFITTED instead'): | |
| k = ft2font.KERNING_UNFITTED | |
| with pytest.warns(mpl.MatplotlibDeprecationWarning, | |
| match='Use Kerning enum values instead'): | |
| assert font.get_kerning(font.get_char_index(ord(left)), | |
| font.get_char_index(ord(right)), | |
| int(k)) == unfitted | |
| with pytest.warns(mpl.MatplotlibDeprecationWarning, | |
| match='Use Kerning.DEFAULT instead'): | |
| k = ft2font.KERNING_DEFAULT | |
| with pytest.warns(mpl.MatplotlibDeprecationWarning, | |
| match='Use Kerning enum values instead'): | |
| assert font.get_kerning(font.get_char_index(ord(left)), | |
| font.get_char_index(ord(right)), | |
| int(k)) == default | |
| def test_ft2font_set_text(): | |
| file = fm.findfont('DejaVu Sans') | |
| font = ft2font.FT2Font(file, hinting_factor=1, _kerning_factor=0) | |
| xys = font.set_text('') | |
| np.testing.assert_array_equal(xys, np.empty((0, 2))) | |
| assert font.get_width_height() == (0, 0) | |
| assert font.get_num_glyphs() == 0 | |
| assert font.get_descent() == 0 | |
| assert font.get_bitmap_offset() == (0, 0) | |
| # This string uses all the kerning pairs defined for test_ft2font_get_kerning. | |
| xys = font.set_text('AADAT.XC-J') | |
| np.testing.assert_array_equal( | |
| xys, | |
| [(0, 0), (512, 0), (1024, 0), (1600, 0), (2112, 0), (2496, 0), (2688, 0), | |
| (3200, 0), (3712, 0), (4032, 0)]) | |
| assert font.get_width_height() == (4288, 768) | |
| assert font.get_num_glyphs() == 10 | |
| assert font.get_descent() == 192 | |
| assert font.get_bitmap_offset() == (6, 0) | |
| def test_ft2font_loading(): | |
| file = fm.findfont('DejaVu Sans') | |
| font = ft2font.FT2Font(file, hinting_factor=1, _kerning_factor=0) | |
| for glyph in [font.load_char(ord('M')), | |
| font.load_glyph(font.get_char_index(ord('M')))]: | |
| assert glyph is not None | |
| assert glyph.width == 576 | |
| assert glyph.height == 576 | |
| assert glyph.horiBearingX == 0 | |
| assert glyph.horiBearingY == 576 | |
| assert glyph.horiAdvance == 640 | |
| assert glyph.linearHoriAdvance == 678528 | |
| assert glyph.vertBearingX == -384 | |
| assert glyph.vertBearingY == 64 | |
| assert glyph.vertAdvance == 832 | |
| assert glyph.bbox == (54, 0, 574, 576) | |
| assert font.get_num_glyphs() == 2 # Both count as loaded. | |
| # But neither has been placed anywhere. | |
| assert font.get_width_height() == (0, 0) | |
| assert font.get_descent() == 0 | |
| assert font.get_bitmap_offset() == (0, 0) | |
| def test_ft2font_drawing(): | |
| expected_str = ( | |
| ' ', | |
| '11 11 ', | |
| '11 11 ', | |
| '1 1 1 1 ', | |
| '1 1 1 1 ', | |
| '1 1 1 1 ', | |
| '1 11 1 ', | |
| '1 11 1 ', | |
| '1 1 ', | |
| '1 1 ', | |
| ' ', | |
| ) | |
| expected = np.array([ | |
| [int(c) for c in line.replace(' ', '0')] for line in expected_str | |
| ]) | |
| expected *= 255 | |
| file = fm.findfont('DejaVu Sans') | |
| font = ft2font.FT2Font(file, hinting_factor=1, _kerning_factor=0) | |
| font.set_text('M') | |
| font.draw_glyphs_to_bitmap(antialiased=False) | |
| image = font.get_image() | |
| np.testing.assert_array_equal(image, expected) | |
| font = ft2font.FT2Font(file, hinting_factor=1, _kerning_factor=0) | |
| glyph = font.load_char(ord('M')) | |
| image = ft2font.FT2Image(expected.shape[1], expected.shape[0]) | |
| font.draw_glyph_to_bitmap(image, -1, 1, glyph, antialiased=False) | |
| np.testing.assert_array_equal(image, expected) | |
| def test_ft2font_get_path(): | |
| file = fm.findfont('DejaVu Sans') | |
| font = ft2font.FT2Font(file, hinting_factor=1, _kerning_factor=0) | |
| vertices, codes = font.get_path() | |
| assert vertices.shape == (0, 2) | |
| assert codes.shape == (0, ) | |
| font.load_char(ord('M')) | |
| vertices, codes = font.get_path() | |
| expected_vertices = np.array([ | |
| (0.843750, 9.000000), (2.609375, 9.000000), # Top left. | |
| (4.906250, 2.875000), # Top of midpoint. | |
| (7.218750, 9.000000), (8.968750, 9.000000), # Top right. | |
| (8.968750, 0.000000), (7.843750, 0.000000), # Bottom right. | |
| (7.843750, 7.906250), # Point under top right. | |
| (5.531250, 1.734375), (4.296875, 1.734375), # Bar under midpoint. | |
| (1.984375, 7.906250), # Point under top left. | |
| (1.984375, 0.000000), (0.843750, 0.000000), # Bottom left. | |
| (0.843750, 9.000000), # Back to top left corner. | |
| (0.000000, 0.000000), | |
| ]) | |
| np.testing.assert_array_equal(vertices, expected_vertices) | |
| expected_codes = np.full(expected_vertices.shape[0], mpath.Path.LINETO, | |
| dtype=mpath.Path.code_type) | |
| expected_codes[0] = mpath.Path.MOVETO | |
| expected_codes[-1] = mpath.Path.CLOSEPOLY | |
| np.testing.assert_array_equal(codes, expected_codes) | |
| def test_fallback_smoke(family_name, file_name): | |
| fp = fm.FontProperties(family=[family_name]) | |
| if Path(fm.findfont(fp)).name != file_name: | |
| pytest.skip(f"Font {family_name} ({file_name}) is missing") | |
| plt.rcParams['font.size'] = 20 | |
| fig = plt.figure(figsize=(4.75, 1.85)) | |
| fig.text(0.05, 0.45, "There are 几个汉字 in between!", | |
| family=['DejaVu Sans', family_name]) | |
| fig.text(0.05, 0.85, "There are 几个汉字 in between!", | |
| family=[family_name]) | |
| # TODO enable fallback for other backends! | |
| for fmt in ['png', 'raw']: # ["svg", "pdf", "ps"]: | |
| fig.savefig(io.BytesIO(), format=fmt) | |
| def test_font_fallback_chinese(fig_test, fig_ref, family_name, file_name): | |
| fp = fm.FontProperties(family=[family_name]) | |
| if file_name not in Path(fm.findfont(fp)).name: | |
| pytest.skip(f"Font {family_name} ({file_name}) is missing") | |
| text = ["There are", "几个汉字", "in between!"] | |
| plt.rcParams["font.size"] = 20 | |
| test_fonts = [["DejaVu Sans", family_name]] * 3 | |
| ref_fonts = [["DejaVu Sans"], [family_name], ["DejaVu Sans"]] | |
| for j, (txt, test_font, ref_font) in enumerate( | |
| zip(text, test_fonts, ref_fonts) | |
| ): | |
| fig_ref.text(0.05, .85 - 0.15*j, txt, family=ref_font) | |
| fig_test.text(0.05, .85 - 0.15*j, txt, family=test_font) | |
| def test_fallback_missing(recwarn, font_list): | |
| fig = plt.figure() | |
| fig.text(.5, .5, "Hello 🙃 World!", family=font_list) | |
| fig.canvas.draw() | |
| assert all(isinstance(warn.message, UserWarning) for warn in recwarn) | |
| # not sure order is guaranteed on the font listing so | |
| assert recwarn[0].message.args[0].startswith( | |
| "Glyph 128579 (\\N{UPSIDE-DOWN FACE}) missing from font(s)") | |
| assert all([font in recwarn[0].message.args[0] for font in font_list]) | |
| def test__get_fontmap(family_name, file_name): | |
| fp = fm.FontProperties(family=[family_name]) | |
| found_file_name = Path(fm.findfont(fp)).name | |
| if file_name not in found_file_name: | |
| pytest.skip(f"Font {family_name} ({file_name}) is missing") | |
| text = "There are 几个汉字 in between!" | |
| ft = fm.get_font( | |
| fm.fontManager._find_fonts_by_props( | |
| fm.FontProperties(family=["DejaVu Sans", family_name]) | |
| ) | |
| ) | |
| fontmap = ft._get_fontmap(text) | |
| for char, font in fontmap.items(): | |
| if ord(char) > 127: | |
| assert Path(font.fname).name == found_file_name | |
| else: | |
| assert Path(font.fname).name == "DejaVuSans.ttf" | |
Xet Storage Details
- Size:
- 40.8 kB
- Xet hash:
- add37b2643404bdd76efd190ff326479b2f91cb802513c73fddfa3e596a0157d
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.