Lire les informations sur les glyphes et les métriques

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

 

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

  Nuget   Pricing Buy
 

L’API Aspose.Font offre une gamme complète de fonctions liées aux polices, notamment la conversion, la manipulation des glyphes, la détection des symboles latins, etc. Certaines de ces fonctionnalités concernent la manipulation des glyphes, qui sont des caractères individuels d’une police de caractères ou des représentations graphiques de symboles/caractères. Pour en savoir plus sur ces unités d’une police, reportez-vous à l’article Introduction to Glyph .

Cette page décrit l’option de lecture des informations Glyph et Metrics, mais pour une compréhension complète de la fonctionnalité, reportez-vous à l’article Using Glyph Objects . Ici, vous trouverez de nombreux exemples de code C++ et découvrirez les capacités d’Aspose.Font pour travailler avec des glyphes et des objets Glyph. Plus d’exemples de code démontrant l’utilisation de Aspose.Font pour manipuler les glyphes peuvent être trouvés dans Aspose Github Project .

Les métriques de glyphe, le terme utilisé ici, font référence aux informations et aux mesures d'un glyphe particulier dans une police. Ils 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 du texte pour assurer un affichage cohérent et précis du texte.

Pour travailler avec des glyphes, nous avons besoin de :

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

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

Package Manager Console Command


    PM> Install-Package Aspose.Font

Étapes pour calculer la largeur de chaîne à l'aide de C++ :

Pour calculer la largeur d’une chaîne à l’aide de glyphes, vous devez d’abord déterminer la largeur de chaque glyphe individuel dans la chaîne, puis additionner ces largeurs pour obtenir le nombre total. Si vous l’expliquez avec les étapes, la commande est la suivante :

  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 des caractères, qui vous donnera l’index du glyphe correspondant.
  3. À l’aide de l’index de glyphe, recherchez les métriques du glyphe dans le tableau des métriques de la police. Les mesures d’un glyphe incluent généralement sa largeur, sa hauteur et sa largeur d’avance.
  4. Additionnez les largeurs avancées de tous les glyphes de la chaîne pour obtenir la largeur totale de la chaîne. Remarque pour faire attention aux informations de crénage.

Si vous décriviez un processus similaire avec le code C++, il ressemblerait à la suivante.

Code C++ pour connaître la largeur de la 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 de glyphe avec des coordonnées à l'aide de 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 de glyphe et additionnez les points.

Code C++ pour trouver les points de glyphe

    //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.