Lire les glyphes et les informations de métriques

Solution API C++ pour calculer la largeur d’une chaîne, calculer les coordonnées des glyphes, et d’autres manipulations avec les glyphes.

 

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

  Nuget   Pricing Buy
 

L’API Aspose.Font propose un éventail complet de fonctions liées aux polices, incluant la conversion, la manipulation des glyphes, la détection des symboles latins, et plus encore. Certaines de ces fonctionnalités concernent la manipulation des glyphes, qui sont les caractères individuels d’une police ou les représentations graphiques de symboles/caractères. Pour en savoir plus sur ces unités d’une police, consultez l’article Introduction aux glyphes .

Cette page décrit l’option pour lire les informations des glyphes et des métriques, mais pour une compréhension complète de la fonctionnalité, reportez‑vous à l’article Utilisation des objets Glyph . Vous y trouverez de nombreux exemples de code C++ et découvrirez les capacités d’Aspose.Font pour travailler avec les glyphes et les objets Glyph. D’autres exemples de code démontrant l’utilisation d’Aspose.Font pour manipuler les glyphes sont disponibles dans le Projet Github d’Aspose.

Les métriques des glyphes, terme utilisé ici, désignent les informations et mesures d’un glyphe particulier dans une police. Elles peuvent inclure des informations telles que la hauteur, la largeur, la largeur d’avance et d’autres dimensions d’un glyphe, qui sont importantes pour le positionnement et l’espacement corrects des caractères dans une police. Ces métriques sont utilisées par les systèmes de mise en page et de rendu de texte afin d’assurer un affichage cohérent et précis du texte.

Pour travailler avec les glyphes, nous avons besoin de :

  • Aspose.Font pour l’API C++, qui est une API riche en fonctionnalités, puissante et facile à utiliser pour la manipulation et la conversion de documents.

  • Ouvrez le gestionnaire de packages NuGet, recherchez Aspose.Font et installez‑le. Vous pouvez également utiliser la commande suivante depuis la console du gestionnaire de packages.

Package Manager Console Command


    PM> Install-Package Aspose.Font

Étapes pour calculer la largeur d’une chaîne en C++ :

Pour calculer la largeur d’une chaîne à l’aide des glyphes, vous devez d’abord déterminer la largeur de chaque glyphe individuel de la chaîne, puis additionner ces largeurs pour obtenir le total. Si on l’explique en étapes, l’ordre est le suivant :

  1. Déterminez la police et la taille que vous souhaitez utiliser pour calculer la largeur de la chaîne.
  2. Pour chaque caractère de la chaîne, déterminez le glyphe correspondant dans la police. Utilisez la table de correspondance des caractères, qui vous donnera l’index du glyphe correspondant.
  3. À l’aide de l’index du glyphe, consultez les métriques du glyphe dans la table des métriques de la police. Les métriques d’un glyphe comprennent généralement sa largeur, sa hauteur et sa largeur d’avance.
  4. Additionnez les largeurs d’avance de tous les glyphes de la chaîne pour obtenir la largeur totale. Faites attention aux informations de crénage.

Si l’on décrit un processus similaire avec le code C++, il se présentera de la manière suivante.

Code C++ pour déterminer la largeur d’une chaîne

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

Étapes pour calculer tous les points des glyphes avec leurs coordonnées en C++ :

  1. Déclarez la liste points de type System::Drawing::Point : cette liste stockera les points d’un segment de chemin de glyphe.
  2. Spécifiez la référence du service Init sur l’interface IPathSegment .
  3. Itérez tous les segments de chemin des glyphes et additionnez les points.

Code C++ pour déterminer les points des glyphes

    //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. Qu’est-ce qu’une métrique de glyphe ?

Les métriques de glyphe sont les paramètres qui influencent la façon dont le glyphe est positionné lors de la création de la mise en page du texte.

2. Que sont les métriques de glyphe ?

Les métriques de glyphe les plus utilisées sont la largeur avancée, l’origine, les roulements latéraux, la ligne de base, l’ascension, l’ascendant, la descente, le descendant, la boîte englobante, la hauteur, la largeur et le crénage.

3. Comment gérer Glyphs avec cette solution API ?

Pour coder des glyphes en C#, utilisez les entités de l’espace de noms Aspose.Font.Glyphs .

4. Quelle est l’importance des métriques de glyphes ?

En comprenant et en ajustant correctement les mesures des glyphes, les typographes et les concepteurs peuvent garantir un espacement, un alignement et une lisibilité optimaux du texte dans les documents imprimés, les interfaces numériques ou les pages Web.