Schriftinformationen lesen

Entdecken Sie Schriftmetriken mit der Aspose.Font API-Lösung für C++. Erfahren Sie detaillierte Einblicke in jeden Strich, jede Kurve und jede Nuance. Mit unserer Lösung können Sie mühelos mit Glyphen arbeiten und so Informationen über die einzigartigen Eigenschaften jeder Schriftart extrahieren.

 

Aspose.Font for C++ Aspose.Font for C++

  Nuget   Pricing Buy
 

Tauchen Sie ein in eine Welt voller Schriftartenmöglichkeiten mit der Aspose.Font API-Lösung für C++, die Ihnen eine Reihe leistungsstarker Funktionen bietet, darunter Schriftartenkonvertierungen, Glyphenmanipulation, Erkennung lateinischer Symbole und mehr. Unsere API ermöglicht es Ihnen auch, mit Glyphen zu arbeiten und Informationen über die in einer Schriftart enthaltenen Glyphen zu erhalten. Verbessern Sie Ihre Designs, optimieren Sie Ihre Projekte und nutzen Sie das volle Potenzial von Glyphen mit Aspose.Font für C++. Warten Sie nicht und holen Sie sich eine kostenlose Testversion!

Eine Glyphe ist ein einzigartiges Design für ein Zeichen oder Symbol in einer Schriftart. Um diese Schriftarteinheit besser zu verstehen, lesen Sie den Artikel Introduction to Glyph . beschreiben das Erscheinungsbild einer Schrift. Diese Metriken können unter anderem Informationen wie die Höhe von Zeichen, die Breite von Zeichen, den Abstand zwischen Zeichen und die Position der Grundlinie enthalten. Sie ermöglichen es Designern und Softwareentwicklern, das Layout von Text in digitalen Dokumenten und Benutzeroberflächen genau vorherzusagen.

Auf dieser Seite wird erläutert, wie Sie verschiedene Schriftartmetriken abrufen können, z. B. die Anzahl der Glyphen, die Buchstabenhöhe, die Breite des Glyphen „A“ usw. Die vollständige Funktionalität der Arbeit mit Glyphen wird jedoch ausführlich im Artikel Verwenden von Glyphenobjekten beschrieben. Das Codebeispiel enthält einen Abschnitt zum Abrufen von Schriftartmetadaten, einschließlich des Schriftartnamens. Diese Art von Funktionalität kann in Webanwendungen integriert werden, wie z. B. die App Font Metadata , die im Aspose-Ökosystem verfügbar ist. Wenn Sie vollständige Beispiele und Datendateien lernen möchten, gehen Sie bitte zu Aspose Github Project .

Um Schriftmetriken zu erhalten, benötigen wir:

  • Aspose.Font für C++ API, eine funktionsreiche, leistungsstarke und benutzerfreundliche API zur Dokumentenbearbeitung und -konvertierung.

  • Öffnen Sie den NuGet-Paket-Manager, suchen Sie nach Aspose.Font und installieren Sie es. Sie können auch den folgenden Befehl in der Paket-Manager-Konsole verwenden.

Package Manager Console Command


    PM> Install-Package Aspose.Font

Schritte zum Abrufen von Schriftartmetriken mit C++:

  1. Informationen über eine Schriftart extrahieren, die eine Instanz der Klasse TtfFont erstellt.
  2. Drucken Sie den Namen der Schriftart mit der Eigenschaft FontName.
  3. Drucken Sie die Anzahl der Glyphen in der Schriftart mit der Eigenschaft NumGlyphs. Die Schriftartmetriken wie Oberlänge, Unterlänge, Tippfehler-Oberlänge, Tippfehler-Unterlänge und UnitsPerEm werden ebenfalls gedruckt.
  4. Der Code ruft dann die```cmap’-Unicode-Codierungstabelle aus der Schriftart ab, die verwendet wird, um Zeichencodes Glyph-Indizes zuzuordnen. Es prüft, ob die Schriftart sowohl die cmap-Tabelle als auch die glyf-Tabelle hat, die verwendet wird, um auf die Glyphen zuzugreifen. Wenn beide Tabellen vorhanden sind, ruft es den „glyf“-Index für das Zeichen „A“ ab und erhält dann die Glyphe für das „A“-Symbol.
  5. Drucken Sie den Begrenzungsrahmen der Glyphe „A“ und seine Breite.

C++-Code zum Abrufen von Informationen über Glyphen der Schriftart

    using Aspose::Font;
    using Aspose::Font::Glyphs;
    using Aspose::Font::Ttf;
    //Font file name with the full path
    
    System::SharedPtr<FontDefinition> fd = System::MakeObject<FontDefinition>(Aspose::Font::FontType::TTF, System::MakeObject<FontFileDefinition>(u"ttf", System::MakeObject<FileSystemStreamSource>(fileName)));
    System::SharedPtr<TtfFont> font = System::DynamicCast_noexcept<Aspose::Font::Ttf::TtfFont>(Aspose::Font::Font::Open(fd));
    
    System::String name = font->get_FontName();
    System::Console::WriteLine(System::String(u"Font name: ") + name);
    System::Console::WriteLine(System::String(u"Glyph count: ") + font->get_NumGlyphs());
    System::String metrics = System::String::Format(u"Font metrics: ascender - {0}, descender - {1}, typo ascender = {2}, typo descender = {3}, UnitsPerEm = {4}", font->get_Metrics()->get_Ascender(), font->get_Metrics()->get_Descender(), font->get_Metrics()->get_TypoAscender(), font->get_Metrics()->get_TypoDescender(), font->get_Metrics()->get_UnitsPerEM());
    
    System::Console::WriteLine(metrics);
    
    //Get cmap unicode encoding table from the font as object TtfCMapFormatBaseTable to access the information about the font glyph for symbol 'A'.
    //Also check that font has object TtfGlyfTable (table 'glyf') to access glyph.
    System::SharedPtr<Aspose::Font::TtfCMapFormats::TtfCMapFormatBaseTable> cmapTable;
    if (font->get_TtfTables()->get_CMapTable() != nullptr)
    {
        cmapTable = font->get_TtfTables()->get_CMapTable()->FindUnicodeTable();
    }
    if (cmapTable != nullptr && font->get_TtfTables()->get_GlyfTable() != nullptr)
    {
        System::Console::WriteLine(System::String(u"Font cmap unicode table: PlatformID = ") + cmapTable->get_PlatformId() + u", PlatformSpecificID = " + cmapTable->get_PlatformSpecificId());
    
        //Code for 'A' symbol
        char16_t unicode = (char16_t)65;
    
        //Glyph index for 'A'
        uint32_t glIndex = cmapTable->GetGlyphIndex(unicode);
    
        if (glIndex != static_cast<uint32_t>(0))
        {
            //Glyph for 'A'
            System::SharedPtr<Glyph> glyph = font->GetGlyphById(glIndex);
            if (glyph != nullptr)
            {
                //Print glyph metrics
                System::Console::WriteLine(u"Glyph metrics for 'A' symbol:");
                System::String bbox = System::String::Format(System::String(u"Glyph BBox: Xmin = {0}, Xmax = {1}") + u", Ymin = {2}, Ymax = {3}", glyph->get_GlyphBBox()->get_XMin(), glyph->get_GlyphBBox()->get_XMax(), glyph->get_GlyphBBox()->get_YMin(), glyph->get_GlyphBBox()->get_YMax());
                System::Console::WriteLine(bbox);
                System::Console::WriteLine(System::String(u"Width:") + font->get_Metrics()->GetGlyphWidth(System::MakeObject<GlyphUInt32Id>(glIndex)));
            }
        }
    }



FAQ

1. Was ist die Schriftartmetrik?

Es ist die Eigenschaft, die bestimmt, wie die Schriftart auf dem Bildschirm gerendert wird. Einige der Metriken wie Aufstieg, Abstieg, Breite und Kerning ähneln Glyph-Metriken .

2. Wie erhalte ich Schriftartmetriken?

Geben Sie die Schriftart an, mit der Sie arbeiten möchten. Extrahieren Sie mithilfe der Eigenschaften der Aspose.Font.IFontMetrics-Klassenschnittstelle die Informationen zu Schriftartmetriken, die Sie benötigen.

3. Was sind Font-Metadaten?

Schriftart-Metadaten sind im Grunde Informationen darüber. Es enthält viele Daten wie Schriftname, Schriftfamilienname, Postscript-Name, Lizenzierung, Autoren- und Designerinformationen und vieles mehr.

4. Wie ändere ich Schriftart-Metadaten?

Um Schriftinformationen online anzuzeigen oder zu ändern, verwenden Sie unsere Anwendung Font Metadata .