Einleitung

Type 1 ist Adobes ursprüngliches skalierbares Schriftformat, das TrueType und OpenType vorausgeht. Type 1 Fonts bestehen aus zwei Dateien: einer .pfb (Printer Font Binary)-Datei, die das verschlüsselte Schriftprogramm enthält, und einer .afm (Adobe Schriftmetriken)-Datei mit Kerning- und Metrikdaten. Obwohl sie von OpenType abgelöst wurden, bleiben Type 1 Fonts in Publishing-Workflows, PostScript-Pipelines und Archivdokumenten verbreitet.

Aspose.Font FOSS für Python bietet direkten Zugriff auf Type 1 Interna über Type1Font, Type1FontData, Type1Serializer und Type1Interpreter. Sie können PFB- oder PFA-Dateien über FontLoader.open laden, die eingebetteten Metadaten des Schriftprogramms inspizieren, Charstrings in Glyph-Pfade interpretieren und Schriften wieder in das PFB- oder PFA-Format serialisieren.

Die Bibliothek wird auf PyPI als aspose-font veröffentlicht und steht unter der MIT-Lizenz. Sie hat keine zwingenden kommerziellen Abhängigkeiten und läuft auf standard Python 3.

Hauptmerkmale

Laden von Type 1 Fonts

Verwenden Sie FontLoader.open, um eine PFB- oder PFA-Datei zu laden. Das zurückgegebene Objekt stellt sowohl die standard Font-Schnittstelle als auch Type 1-spezifische Funktionalität über die Type1Font-Klasse bereit:

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 erkennt das Type-1-Format automatisch aus dem Dateikopf. PFB- und PFA-Dateien werden beide unterstützt.

Lade AFM-Metriken

Type-1-Schriften liefern ihre Metriken in einer separaten .afm-Datei. Die Type1Font-Klasse stellt eine load_afm(path)-Methode bereit, die die AFM-Daten an das geladene Schriftobjekt anhängt und so Kerns-Paar-Nachschlagen über get_kern_pairs() ermöglicht.

Ohne die AFM-Datei gibt get_kern_pairs() eine leere Liste zurück, weil Kerns-Daten in der AFM-Datei und nicht im PFB-Programm selbst gespeichert sind. Die load_afm-Methode akzeptiert einen Dateipfad-String, der auf die zugehörige .afm-Datei verweist.

Zugriff auf Type1FontData-Metadaten

Die Type1FontData-Klasse stellt das im Type-1-Datei eingebettete Schriftprogramm-Dictionary bereit. Es enthält Metriken, Begrenzungs-Box, Kodierungsvektor, Charstrings und Subroutinen:

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

Type1FontData-Eigenschaften:

  • font_name (str) — PostScript Name der Schrift
  • full_name (str) — vollständiger menschenlesbarer Name
  • family_name (str) — Schriftfamilie
  • weight (str) — Gewichtszeichenkette (z.B. "Medium")
  • italic_angle (float) — Kursivwinkel in Grad
  • is_fixed_pitch (bool) — true für Monospace-Schriften
  • font_bbox (tuple[int, int, int, int]) — Begrenzungsrahmen (llx, lly, urx, ury)
  • underline_position (int) — Unterstreichungsposition in Schrifteinheiten
  • underline_thickness (int) — Unterstreichungsstrichdicke
  • encoding (list[str]) — 256-Slot-Kodierungsvektor (PostScript Glyph-Namen)
  • charstrings (dict[str, bytes]) — Glyph-Name → Charstring-Byte-Mapping
  • subrs (list[bytes]) — von der Charstring-Engine verwendete Subroutinen-Byte-Strings
  • len_iv (int) — lenIV-Verschlüsselungsparameter

Interpretation von Charstrings

Type1Interpreter dekodiert Type-1-Charstring-Programme in GlyphPath-Konturen. Übergeben Sie die rohen Charstring-Bytes von Type1FontData.charstrings an 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 liefert ein (GlyphPath, int)-Tupel. Das GlyphPath enthält die Zeichenbefehle für die Glyphen-Kontur. Die Ganzzahl ist die endgültige Stapeltiefe nach der Ausführung, was beim Debuggen fehlerhafter Charstrings nützlich ist.

Serialisierung in PFB und PFA

Type1Serializer konvertiert eine geladene Type-1-Schrift zurück in das binäre PFB- oder das Text-PFA-Format. Beide Methoden akzeptieren jede Font-Instanz und geben rohe Bytes zurück:

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")

Schriftmetriken

Metriken und Kodierung sind über die standardmäßige Font-Schnittstelle zugänglich:

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}")

Schnellstart

Bibliothek installieren:

.venv/bin/pip install aspose-font

Lade eine PFB-Schrift und inspiziere sie:

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")

Unterstützte Formate

FormatErweiterungLesenSchreiben
TTF.ttf✓—
OTF.otf✓—
EOT.eot✓—
CFF.cff✓—
TYPE1.pfb/.pfa✓—
WOFF.woff✓—
WOFF2.woff2✓—

Type-1-Schriften werden über FontLoader.open geladen und über Type1Serializer serialisiert.

Open Source & Lizenzierung

Aspose.Font FOSS für Python wird unter der MIT-Lizenz veröffentlicht. Sie können es kostenlos in privaten, kommerziellen und Open-Source-Projekten verwenden. Der Quellcode ist verfügbar auf GitHub und das Paket wird über PyPI als aspose-font verteilt.

Erste Schritte

Verwandte Ressourcen