Wprowadzenie
Wbudowany OpenType (EOT) to kompaktowy format czcionek pierwotnie opracowany do osadzania czcionek TrueType na stronach internetowych. Plik EOT otacza czcionkę TTF lub OTF nagłówkiem o stałym rozmiarze, zawierającym pola metadanych opisujące wymiary czcionki, wersję, zestaw znaków oraz uprawnienia do osadzania. Chociaż nowoczesny rozwój stron internetowych w dużej mierze przeszedł na WOFF/WOFF2, pliki EOT nadal są używane w starszych dokumentach i aplikacjach korporacyjnych.
Aspose.Font FOSS dla Python zapewnia bezpośredni dostęp do wewnętrznych elementów czcionki EOT poprzez klasę EotFont oraz jej towarzyszącą EotHeader. Możesz załadować plik EOT przy użyciu FontLoader.open, odczytać pola nagłówka, przeglądać wewnętrzny TtfFont i zserializować wynik z powrotem do bajtów lub do pliku przy użyciu Font.save. Biblioteka jest opublikowana na PyPI jako aspose-font i licencjonowana na warunkach licencji MIT. Nie ma obowiązkowych komercyjnych zależności i działa ze standardowym środowiskiem uruchomieniowym Python 3.
Kluczowe cechy
Ładowanie czcionek EOT
Użyj FontLoader.open, aby załadować plik EOT z ścieżki lub obiektu bajtów. Metoda zwraca instancję EotFont, gdy wykryje sygnaturę EOT:
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 odczytuje rozszerzenie pliku i magiczny nagłówek, aby automatycznie wykryć format. Żaden argument font_type nie jest wymagany dla typowych plików czcionek.
Odczytywanie metadanych EotHeader
EotFont udostępnia pola nagłówka bezpośrednio jako właściwości klasy. Odpowiadają one polom zdefiniowanym w specyfikacji binarnej EOT:
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)
Klasa EotFont udostępnia następujące metadane nagłówka jako właściwości:
eot_version(int) — wersja formatu EOT (np.0x00020002)flags(int) — flagi uprawnień osadzaniacharset(int) — identyfikator zestawu znaków (0 = ANSI, 1 = DEFAULT)italic(int) — flaga kursywy (0 lub 1)weight(int) — grubość czcionki (np., 400 dla Regular, 700 dla Bold)fs_type(int) — OS/2 bity osadzania fsType
Użyj flags i fs_type, aby określić, czy czcionka zezwala na podzbiory lub osadzanie, co jest istotne przy przetwarzaniu czcionek w łańcuchach dystrybucji.
Dostęp do wewnętrznego TtfFont
Każdy EotFont opakowuje standardową czcionkę TrueType. Właściwość inner_font zwraca instancję TtfFont, dając dostęp do pełnego zestawu tabel TrueType:
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)
Właściwość inner_font w EotFont zwraca opakowaną instancję TtfFont, zapewniając dostęp do pełnego zestawu tabel TrueType, par kerningu i tabel kodowania.
Serializacja EOT do bajtów
EotSerializer.serialize konwertuje dowolny obiekt Font na surowy ciąg bajtów EOT:
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")
Konwertowanie TTF na EOT
EotSerializer.serialize akceptuje dowolną instancję Font, więc możesz wczytać TTF i bezpośrednio zserializować go do bajtów EOT:
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)
Metryki czcionki i pary kerningowe
EotFont dziedziczy pełny interfejs Font, więc metryki i kodowanie są dostępne bezpośrednio, bez przechodzenia przez inner_font:
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}")
Szybki start
Zainstaluj bibliotekę:
.venv/bin/pip install aspose-font
Wczytaj i przejrzyj czcionkę EOT:
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")
Obsługiwane formaty
| Format | Rozszerzenie | Odczyt | Zapis |
|---|---|---|---|
| TTF | .ttf | ✓ | — |
| OTF | .otf | ✓ | — |
| EOT | .eot | ✓ | — |
| CFF | .cff | ✓ | — |
| TYPE1 | .pfb/.pfa | ✓ | — |
| WOFF | .woff | ✓ | — |
| WOFF2 | .woff2 | ✓ | — |
Wszystkie wymienione powyżej formaty są obsługiwane przy wczytywaniu poprzez FontLoader.open. Zapisywanie do konkretnego formatu używa Font.save lub EotSerializer.serialize dla EOT.
Open Source i licencjonowanie
Aspose.Font FOSS dla Python jest udostępniony na licencji MIT. Możesz go używać w projektach osobistych, komercyjnych i open-source bez żadnych kosztów. Kod źródłowy jest dostępny na GitHub, a pakiet jest dystrybuowany przez PyPI jako aspose-font.
