Introduzione
Type 1 è il formato di font scalabile originale di Adobe, antecedente a TrueType e OpenType. I font Type 1 sono composti da due file: un file .pfb (Printer Font Binary) contenente il programma del font criptato, e un file .afm (Adobe Metriche del Font) con dati di kerning e metriche. Nonostante sia stato sostituito da OpenType, i font Type 1 rimangono diffusi nei flussi di lavoro editoriali, nelle pipeline PostScript e nei documenti d’archivio.
Aspose.Font FOSS per Python fornisce accesso diretto agli internals di Type 1 tramite Type1Font, Type1FontData, Type1Serializer e Type1Interpreter. È possibile caricare file PFB o PFA tramite FontLoader.open, ispezionare i metadati del programma del font incorporato, interpretare le charstring in percorsi di glifi e serializzare i font nuovamente in formato PFB o PFA.
La libreria è pubblicata su PyPI come aspose-font ed è licenziata sotto la MIT License. Non ha dipendenze commerciali obbligatorie e funziona su Python 3 standard.
Caratteristiche principali
Caricamento dei font Type 1
Usa FontLoader.open per caricare un file PFB o PFA. L’oggetto restituito espone sia l’interfaccia standard Font sia le funzionalità specifiche di Type 1 tramite la classe Type1Font:
from aspose_font import FontLoader
loaded = FontLoader.open("fonts/Courier.pfb")
print(loaded.font_name) # e.g. "Courier"
print(loaded.font_family) # e.g. "Courier"
print(loaded.num_glyphs) # number of defined glyphs
print(loaded.font_style) # style string, e.g. "Regular"
FontLoader.open rileva automaticamente il formato Type 1 dall’intestazione del file. I file PFB e PFA sono entrambi supportati.
Caricamento metriche AFM
I font Type 1 includono le loro metriche in un file .afm separato. La classe Type1Font espone un metodo load_afm(path) che collega i dati AFM all’oggetto font caricato, consentendo la ricerca di coppie di kern tramite get_kern_pairs().
Senza il file AFM, get_kern_pairs() restituisce un elenco vuoto perché i dati di kern si trovano nel file AFM, non nel programma PFB stesso. Il metodo load_afm accetta una stringa di percorso file che punta al file .afm complementare.
Accesso ai metadati Type1FontData
La classe Type1FontData espone il dizionario del programma di font incorporato nel file Type 1. Include metriche, bounding box, vettore di codifica, charstring e subroutine:
from aspose_font.type1.data import Type1FontData
# Type1FontData is the font program dictionary parsed from the PFB
# Access its properties to inspect the raw PostScript font data
Proprietà Type1FontData:
font_name(str) — PostScript nome del fontfull_name(str) — nome completo leggibile dall’uomofamily_name(str) — famiglia di caratteriweight(str) — stringa di peso (ad es."Medium")italic_angle(float) — angolo italico in gradiis_fixed_pitch(bool) — vero per i font monospaziofont_bbox(tuple[int, int, int, int]) — box di delimitazione(llx, lly, urx, ury)underline_position(int) — posizione della sottolineatura in unità del fontunderline_thickness(int) — spessore del tratto della sottolineaturaencoding(list[str]) — vettore di codifica a 256 slot (PostScript nomi di glifo)charstrings(dict[str, bytes]) — mappatura nome glifo → byte charstringsubrs(list[bytes]) — stringhe di byte di subroutine utilizzate dal motore charstringlen_iv(int) — parametro di cifratura lenIV
Interpretazione delle Charstrings
Type1Interpreter decodifica i programmi Type 1 charstring in contorni GlyphPath. Passare i byte raw della charstring da Type1FontData.charstrings a interpret:
from aspose_font.type1.interpreter import Type1Interpreter
interpreter = Type1Interpreter()
charstring = b"\x0e" # seac or other charstring bytes
glyph_path, stack_depth = interpreter.interpret(charstring)
for cmd in glyph_path.commands:
print(cmd)
interpret restituisce una tupla (GlyphPath, int). Il GlyphPath contiene i comandi di disegno per il contorno del glifo. L’intero è la profondità finale dello stack dopo l’esecuzione, utile per il debug di charstring malformate.
Serializzazione in PFB e PFA
Type1Serializer converte un font Type 1 caricato nuovamente in formato binario PFB o testo PFA. Entrambi i metodi accettano qualsiasi istanza Font e restituiscono byte grezzi:
from aspose_font import FontLoader
from aspose_font.type1.serializer import Type1Serializer
loaded = FontLoader.open("fonts/Courier.pfb")
# Serialize to PFB (binary) format
pfb_bytes = Type1Serializer.serialize_pfb(loaded)
with open("output/Courier_copy.pfb", "wb") as fh:
fh.write(pfb_bytes)
# Serialize to PFA (text) format
pfa_bytes = Type1Serializer.serialize_pfa(loaded)
with open("output/Courier_copy.pfa", "wb") as fh:
fh.write(pfa_bytes)
print(f"PFB: {len(pfb_bytes)} bytes")
print(f"PFA: {len(pfa_bytes)} bytes")
Metriche del Font
Metriche e codifica sono accessibili tramite l’interfaccia standard Font:
from aspose_font import FontLoader
loaded = FontLoader.open("fonts/Courier.pfb")
metrics = loaded.metrics
print(f"Units per em : {metrics.units_per_em}")
print(f"Ascender : {metrics.ascender}")
print(f"Descender : {metrics.descender}")
print(f"Underline pos : {metrics.underline_position}")
print(f"Underline tck : {metrics.underline_thickness}")
Avvio Rapido
Installa la libreria:
.venv/bin/pip install aspose-font
Carica un font PFB e ispezionalo:
from aspose_font import FontLoader
from aspose_font.type1.serializer import Type1Serializer
loaded = FontLoader.open("Courier.pfb")
print(f"Font name : {loaded.font_name}")
print(f"Family : {loaded.font_family}")
print(f"Style : {loaded.font_style}")
print(f"Glyphs : {loaded.num_glyphs}")
metrics = loaded.metrics
print(f"UPM : {metrics.units_per_em}")
# Round-trip: serialize back to PFB
pfb_bytes = Type1Serializer.serialize_pfb(loaded)
print(f"Serialized: {len(pfb_bytes)} bytes")
Formati supportati
| Formato | Estensione | Leggi | Scrivi |
|---|---|---|---|
| TTF | .ttf | ✓ | — |
| OTF | .otf | ✓ | — |
| EOT | .eot | ✓ | — |
| CFF | .cff | ✓ | — |
| TYPE1 | .pfb/.pfa | ✓ | — |
| WOFF | .woff | ✓ | — |
| WOFF2 | .woff2 | ✓ | — |
I font Type 1 vengono caricati tramite FontLoader.open e serializzati tramite Type1Serializer.
Open Source e Licenze
Aspose.Font FOSS per Python è rilasciato sotto la MIT License. Puoi usarlo in progetti personali, commerciali e open-source senza alcun costo. Il codice sorgente è disponibile su GitHub e il pacchetto è distribuito tramite PyPI come aspose-font.
