Glyphen und Metrikinformationen lesen

C++‑API-Lösung zur Berechnung der Textbreite, zur Berechnung von Glyphenkoordinaten und zu anderen Manipulationen mit Glyphen.

Die Aspose.Font‑API bietet ein umfassendes Spektrum an fontbezogenen Funktionen, einschließlich Konvertierung, Glyphenmanipulation, Erkennung lateinischer Symbole und mehr. Einige dieser Funktionen beziehen sich auf die Manipulation von Glyphen, die einzelne Zeichen eines Schriftsatzes oder grafische Darstellungen von Symbolen/Zeichen sind. Um mehr über diese Einheiten einer Schrift zu erfahren, siehe den Artikel Introduction to Glyph .

Diese Seite skizziert die Möglichkeit, Glyphen- und Metrikinformationen zu lesen, aber für ein vollständiges Verständnis der Funktionalität siehe den Artikel Using Glyph Objects . Hier finden Sie zahlreiche C++‑Codebeispiele und erfahren mehr über die Möglichkeiten von Aspose.Font bei der Arbeit mit Glyphen und Glyph‑Objekten. Weitere Codebeispiele, die die Verwendung von Aspose.Font zur Manipulation von Glyphen demonstrieren, finden Sie im Aspose Github Project .

Glyph‑Metriken, der hier verwendete Begriff, beziehen sich auf die Informationen und Messungen eines bestimmten Glyphen in einer Schrift. Sie können Angaben wie Höhe, Breite, Vorwärtsbreite und andere Abmessungen eines Glyphen umfassen, die für die korrekte Positionierung und den Abstand von Zeichen in einer Schrift wichtig sind. Diese Metriken werden von Textlayout‑ und Rendering‑Systemen verwendet, um eine konsistente und genaue Anzeige von Text sicherzustellen.

Um mit Glyphen zu arbeiten, benötigen wir:

Aspose.Font für C++ API, die eine funktionsreiche, leistungsstarke und einfach zu nutzende Dokumenten‑Manipulations‑ und Konvertierungs‑API ist.
Öffnen Sie den NuGet‑Paket-Manager, suchen Sie nach Aspose.Font und installieren Sie es. Sie können auch den folgenden Befehl in der Package‑Manager‑Konsole verwenden.

Package Manager Console Command


    PM> Install-Package Aspose.Font

Schritte zur Berechnung der Textbreite mit C++:

Um die Breite einer Zeichenkette mit Glyphen zu berechnen, müssen Sie zunächst die Breite jedes einzelnen Glyphen in der Zeichenkette bestimmen und anschließend diese Breiten summieren, um die Gesamtzahl zu erhalten. Wenn man es mit Schritten erklärt, ist die Reihenfolge wie folgt:

Bestimmen Sie die Schriftart und Größe, die Sie zur Berechnung der Breite der Zeichenkette verwenden möchten.
Für jedes Zeichen in der Zeichenkette bestimmen Sie das entsprechende Glyph im Font. Verwenden Sie die Zeichenzuordnung, die Ihnen den Index des entsprechenden Glyphen liefert.
Verwenden Sie den Glyph‑Index, um die Metriken des Glyphen in der Metriktabelle des Fonts nachzuschlagen. Die Metriken eines Glyphen umfassen typischerweise seine Breite, Höhe und Vorwärtsbreite.
Addieren Sie die Vorwärtsbreiten aller Glyphen in der Zeichenkette, um die Gesamtlänge zu erhalten. Achten Sie dabei auf Kerning‑Informationen.

Wenn man einen ähnlichen Prozess mit C++‑Code beschreibt, sieht er wie folgt aus.

C++‑Code zur Ermittlung der Textbreite

    using System;
    using System::IO;
    using System::Drawing;
    using System::Collections::Generic;
    using Aspose::Font::Sources;
    using Aspose::Font::Glyphs;
    using Aspose::Font::RenderingPath;

        //Declare the text and other constants
        const System::String text = u"Hello world";
        const int32_t fontSize = 10;
    
        //Declare the variable for string width
        double width = 0;
    
        //Get glyph for each letter in text and calculate width for whole text.
        //The same result can be achieved using method font.Metrics.MeasureString(text, fontSize).
        for (char16_t symbol : text)
        {
            System::SharedPtr<GlyphId> gid = this->_font->get_Encoding()->DecodeToGid(symbol);
            System::SharedPtr<Glyph> glyph = this->_font->GetGlyphById(gid);
            width += (glyph->get_WidthVectorX() / this->_font->get_Metrics()->get_UnitsPerEM()) * fontSize;
        }
	    font->get_Metrics()->MeasureString(text, width);

        //Print the output results
        System::Console::WriteLine(System::String::Format(u"Width for text \"{0}\" with font size {2} is equal {3}.", text, FontName, fontSize, width));

Schritte zur Berechnung aller Glyphenpunkte mit Koordinaten unter Verwendung von C++:

Deklarieren Sie die Liste points vom Typ System::Drawing::Point: Diese Liste speichert die Punkte eines Glyphen‑Pfadsegments.
Geben Sie die Init‑Service-Referenz für das Interface IPathSegment an.
Iterieren Sie über alle Glyphen‑Pfadsegmente und summieren Sie die Punkte.

C++‑Code zur Ermittlung von Glyphenpunkten

    //Declare the resultant list with points
    System::SharedPtr<System::Collections::Generic::List<System::Drawing::Point>> points =
    System::MakeObject<System::Collections::Generic::List<System::Drawing::Point>>();
    
    //Init the service reference on IPathSegment
    System::SharedPtr<IPathSegment> prevSegment;
    
    //Iterate all the glyph path segments and collect points
    for (auto&& segment : glyph->get_Path()->get_Segments())
    {
        if ((System::ObjectExt::Is<LineTo>(segment)) || (System::ObjectExt::Is<CurveTo>(segment)))
        {
            if (System::ObjectExt::Is<MoveTo>(prevSegment))
            {
                System::SharedPtr<MoveTo> moveTo = System::DynamicCast_noexcept<Aspose::Font::RenderingPath::MoveTo>(prevSegment);
                AddPoint((int32_t)moveTo->get_X(), (int32_t)moveTo->get_Y(), points);
            }
            if (System::ObjectExt::Is<LineTo>(segment))
            {
                System::SharedPtr<LineTo> line = System::DynamicCast_noexcept<Aspose::Font::RenderingPath::LineTo>(segment);
                AddPoint((int32_t)line->get_X(), (int32_t)line->get_Y(), points);
            }
            else if (System::ObjectExt::Is<CurveTo>(segment))
            {
                System::SharedPtr<CurveTo> curve = System::DynamicCast_noexcept<Aspose::Font::RenderingPath::CurveTo>(segment);
                AddPoint((int32_t)curve->get_X1(), (int32_t)curve->get_Y1(), points);
                AddPoint((int32_t)curve->get_X2(), (int32_t)curve->get_Y2(), points);
                AddPoint((int32_t)curve->get_X3(), (int32_t)curve->get_Y3(), points);
            }
        }
        prevSegment = segment;
    }

FAQ

1. Was ist eine Glyphenmetrik?

Glyph-Metriken sind die Parameter, die beeinflussen, wie die Glyphe positioniert wird, wenn das Textlayout erstellt wird.

2. Was sind Glyphenmetriken?

Die am häufigsten verwendeten Glyphenmetriken sind Vorlaufbreite, Ursprung, Seitenlage, Grundlinie, Aufstieg, Oberlänge, Abstieg, Unterlänge, Begrenzungsrahmen, Höhe, Breite und Kerning.

3. Wie verwaltet man Glyphen mit dieser API-Lösung?

Verwenden Sie zum Codieren von Glyphen in C# die Entitäten des Aspose.Font.Glyphs -Namespace.

4. Welche Bedeutung haben Glyphenmetriken?

Durch das Verständnis und die richtige Anpassung der Glyphenmetriken können Typografen und Designer optimale Abstände, Ausrichtung und Lesbarkeit von Text in gedruckten Materialien, digitalen Schnittstellen oder Webseiten sicherstellen.