Lesen Sie die Informationen zu Glyphen und Metriken

C++-API-Lösung zum Berechnen der Zeichenfolgenbreite, Berechnen von Glyphenkoordinaten und anderer Manipulationen mit Glyphen.

 

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

  Nuget   Pricing Buy
 

Die Aspose.Font-API bietet eine umfassende Auswahl an schriftbezogenen Funktionen, einschließlich Konvertierung, Bearbeitung von Glyphen, Erkennung lateinischer Symbole und mehr. Einige dieser Merkmale beziehen sich auf die Manipulation von Glyphen, bei denen es sich um einzelne Zeichen einer Schriftart oder grafische Darstellungen von Symbolen/Zeichen handelt. Weitere Informationen zu diesen Einheiten einer Schriftart finden Sie im Artikel Introduction to Glyph .

Auf dieser Seite wird die Option zum Lesen von Glyph- und Metrikinformationen beschrieben, aber für ein vollständiges Verständnis der Funktionalität lesen Sie den Artikel Using Glyph Objects . Hier finden Sie zahlreiche C++-Codebeispiele und erfahren mehr über die Funktionen von Aspose.Font für die Arbeit mit Glyphen und Glyph-Objekten. Weitere Codebeispiele, die die Verwendung von Aspose.Font zum Bearbeiten von Glyphen demonstrieren, finden Sie im Aspose Github Project .

Glyph-Metriken, der hier verwendete Begriff, beziehen sich auf die Informationen und Maße einer bestimmten Glyphe in einer Schriftart. Sie können Informationen wie Höhe, Breite, erweiterte Breite und andere Abmessungen einer Glyphe enthalten, die für die richtige Positionierung und den richtigen Abstand von Zeichen in einer Schriftart 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, 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 Berechnen der Zeichenfolgenbreite mit C++:

Um die Breite einer Zeichenfolge mithilfe von Glyphen zu berechnen, müssen Sie zuerst die Breite jeder einzelnen Glyphe in der Zeichenfolge bestimmen und diese Breiten dann summieren, um die Gesamtzahl zu erhalten. Wenn Sie es mit Schritten erklären, ist die Reihenfolge die nächste:

  1. Bestimmen Sie die Schriftart und -größe, die Sie verwenden möchten, um die Breite der Zeichenfolge zu berechnen.
  2. Bestimmen Sie für jedes Zeichen in der Zeichenfolge die entsprechende Glyphe in der Schriftart. Verwenden Sie die Zeichentabelle, die Ihnen den Index der entsprechenden Glyphe gibt.
  3. Schlagen Sie mithilfe des Glyphenindex die Metriken für die Glyphe in der Metriktabelle der Schriftart nach. Die Metriken für eine Glyphe umfassen typischerweise ihre Breite, Höhe und Fortschrittsbreite.
  4. Addieren Sie die erweiterten Breiten aller Glyphen in der Zeichenfolge, um die Gesamtbreite der Zeichenfolge zu erhalten. Beachten Sie die Kerning-Informationen.

Wenn Sie einen ähnlichen Prozess mit dem C++-Code beschreiben, würde es in die nächste Richtung aussehen.

C++-Code zum Ermitteln der Zeichenfolgenbreite

    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 zum Berechnen aller Glyphenpunkte mit Koordinaten mit C++:

  1. Deklarieren Sie die Liste Punkte vom Typ System::Drawing::Point: Diese Liste speichert die Punkte von a Glyphenpfadsegment..
  2. Geben Sie die Init-Dienstreferenz auf der Schnittstelle IPathSegment an.
  3. Iterieren Sie alle Glyphenpfadsegmente und summieren Sie die Punkte.

C++-Code zum Ermitteln 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.