Inleiding
Embedded OpenType (EOT) is een compact lettertype-formaat dat oorspronkelijk is ontwikkeld om TrueType lettertypen in webpagina’s in te sluiten. Een EOT-bestand omsluit een TTF- of OTF-lettertype met een vaste-grootte header die metadata-velden bevat die de lettertype-afmetingen, versie, tekenset en insluitingsrechten beschrijven. Hoewel moderne webontwikkeling grotendeels is overgestapt op WOFF/WOFF2, blijven EOT-bestanden in omloop in legacy-documenten en bedrijfsapplicaties.
Aspose.Font FOSS voor Python biedt directe toegang tot de interne structuur van EOT-fonts via de EotFont klasse en zijn companion EotHeader. Je kunt een EOT-bestand laden met FontLoader.open, headervelden lezen, de interne TtfFont doorlopen, en het resultaat serialiseren terug naar bytes of naar een bestand met Font.save. De bibliotheek wordt gepubliceerd op PyPI als aspose-font en gelicentieerd onder de MIT License. Het heeft geen verplichte commerciële afhankelijkheden en werkt met de standaard Python 3 runtime.
Belangrijkste kenmerken
EOT Fonts laden
Gebruik FontLoader.open om een EOT-bestand te laden vanaf een pad of een bytes-object. De methode retourneert een EotFont-instantie wanneer de EOT-handtekening wordt gedetecteerd:
from aspose_font import FontLoader, EotFont
font = FontLoader.open("fonts/sample.eot")
assert isinstance(font, EotFont)
print(font.font_name) # e.g. "Roboto"
print(font.font_family) # e.g. "Roboto"
print(font.num_glyphs) # number of glyphs in the inner font
FontLoader.open leest de bestandsextensie en header-magic om het formaat automatisch te detecteren. Er is geen font_type-argument vereist voor gangbare lettertype-bestanden.
Lezen van EotHeader metadata
EotFont maakt de headervelden rechtstreeks beschikbaar als eigenschappen op de klasse. Deze komen overeen met de velden die gedefinieerd zijn in de EOT-binaire specificatie:
from aspose_font import FontLoader, EotFont, EotSerializer
# Load EOT — FontLoader returns an EotFont instance for .eot files
loaded = FontLoader.open("fonts/sample.eot")
# Serialize back to bytes to confirm the font loaded correctly
eot_bytes = EotSerializer.serialize(loaded)
print(f"EOT data loaded: {len(eot_bytes)} bytes")
# Base Font properties work on any loaded font
print("Font name:", loaded.font_name)
print("Glyphs :", loaded.num_glyphs)
De EotFont klasse maakt de volgende header-metadata beschikbaar als eigenschappen:
eot_version(int) — EOT-formaatversie (bijv.0x00020002)flags(int) — inbeddingspermissievlaggencharset(int) — tekenset-identificatie (0 = ANSI, 1 = DEFAULT)italic(int) — cursief-vlag (0 of 1)weight(int) — lettertypegewicht (bijv. 400 voor Regular, 700 voor Bold)fs_type(int) — OS/2 fsType-inbeddingsbits
Gebruik flags en fs_type om te bepalen of het lettertype subsetting of insluiting toestaat, wat relevant is bij het verwerken van lettertypen voor herdistributiepijplijnen.
Toegang tot de interne TtfFont
Elke EotFont wikkelt een standaard TrueType lettertype. De inner_font eigenschap retourneert de TtfFont instantie, waardoor je toegang krijgt tot de volledige TrueType tabelset:
from aspose_font import FontLoader
loaded = FontLoader.open("fonts/sample.eot")
# Metrics are accessible directly from the loaded font
metrics = loaded.metrics
print("Units per em :", metrics.units_per_em)
print("Ascender :", metrics.ascender)
print("Descender :", metrics.descender)
print("Line gap :", metrics.line_gap)
De inner_font eigenschap op EotFont retourneert de ingepakte TtfFont instantie, en biedt toegang tot de volledige TrueType tabelset, kerningparen en coderingstabellen.
EOT serialiseren naar bytes
EotSerializer.serialize zet elk Font object om in een ruwe EOT byte-string:
from aspose_font import FontLoader, EotFont, EotSerializer
font = FontLoader.open("fonts/sample.eot")
assert isinstance(font, EotFont)
eot_bytes = EotSerializer.serialize(font)
with open("output/sample_copy.eot", "wb") as fh:
fh.write(eot_bytes)
print(f"Serialized {len(eot_bytes)} bytes")
TTF converteren naar EOT
EotSerializer.serialize accepteert elke Font instantie, zodat je een TTF kunt laden en direct naar EOT-bytes kunt serialiseren:
from aspose_font import FontLoader, EotFont, EotSerializer
ttf = FontLoader.open("fonts/Roboto-Regular.ttf")
eot_bytes = EotSerializer.serialize(ttf)
with open("output/Roboto-Regular.eot", "wb") as fh:
fh.write(eot_bytes)
reloaded = FontLoader.open("output/Roboto-Regular.eot")
assert isinstance(reloaded, EotFont)
print("Converted and verified:", reloaded.font_name)
Lettertype-metrieken en kernparen
De EotFont erft de volledige Font interface, zodat metrieken en codering direct beschikbaar zijn zonder via inner_font te gaan:
from aspose_font import FontLoader
loaded = FontLoader.open("fonts/sample.eot")
metrics = loaded.metrics
print(f"Ascender : {metrics.ascender}")
print(f"Descender: {metrics.descender}")
print(f"Line gap : {metrics.line_gap}")
print(f"Underline: {metrics.underline_position}")
for pair in loaded.get_kern_pairs():
print(f" Kern: {pair}")
Snelstart
Installeer de bibliotheek:
.venv/bin/pip install aspose-font
Laad en inspecteer een EOT-lettertype:
from aspose_font import FontLoader, EotFont, EotSerializer
loaded = FontLoader.open("sample.eot")
# Base font info
print(f"Font name : {loaded.font_name}")
print(f"Glyphs : {loaded.num_glyphs}")
# Metrics
metrics = loaded.metrics
print(f"UPM : {metrics.units_per_em}")
print(f"Ascender : {metrics.ascender}")
# Serialize the loaded font back to EOT bytes
eot_bytes = EotSerializer.serialize(loaded)
print(f"Serialized: {len(eot_bytes)} bytes")
Ondersteunde formaten
| Formaat | Extensie | Lezen | Schrijven |
|---|---|---|---|
| TTF | .ttf | ✓ | — |
| OTF | .otf | ✓ | — |
| EOT | .eot | ✓ | — |
| CFF | .cff | ✓ | — |
| TYPE1 | .pfb/.pfa | ✓ | — |
| WOFF | .woff | ✓ | — |
| WOFF2 | .woff2 | ✓ | — |
Alle bovenstaande formaten worden ondersteund voor laden via FontLoader.open. Schrijven naar een specifiek formaat gebruikt Font.save of EotSerializer.serialize voor EOT.
Open source & licensering
Aspose.Font FOSS voor Python wordt uitgebracht onder de MIT License. Je kunt het gratis gebruiken in persoonlijke, commerciële en open-sourceprojecten. De broncode is beschikbaar op GitHub en het pakket wordt gedistribueerd via PyPI als aspose-font.
