Leia as informações de glifos e métricas

Solução de API C++ para calcular a largura da string, calcular as coordenadas do glifo e outras manipulações com glifos.

 

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

  Nuget   Pricing Buy
 

A API Aspose.Font oferece uma gama abrangente de funções relacionadas a fontes, incluindo conversão, manipulação de glifos, detecção de símbolos latinos e muito mais. Alguns desses recursos pertencem à manipulação de glifos, que são caracteres individuais de um tipo de letra ou representações gráficas de símbolos/caracteres. Para entender mais sobre essas unidades de uma fonte, consulte o artigo Introduction to Glyph .

Esta página descreve a opção de leitura de informações de Glyph e Métricas, mas para uma compreensão completa da funcionalidade, consulte o artigo Using Glyph Objects . Aqui, você encontrará vários exemplos de código C++ e aprenderá sobre os recursos do Aspose.Font para trabalhar com glifos e objetos Glyph. Mais exemplos de código demonstrando o uso de Aspose.Font para manipular Glyphs podem ser encontrados em Aspose Github Project .

Métricas de glifos, o termo usado aqui, referem-se às informações e medições de um glifo específico em uma fonte. Eles podem incluir informações como altura, largura, largura de avanço e outras dimensões de um glifo, que são importantes para o posicionamento e espaçamento adequados dos caracteres em uma fonte. Essas métricas são usadas por sistemas de renderização e layout de texto para garantir uma exibição de texto consistente e precisa.

Para trabalhar com glifos, precisamos:

  • Aspose.Font para C++ API, que é uma API de manipulação e conversão de documentos rica em recursos, poderosa e fácil de usar.

  • Abra o gerenciador de pacotes NuGet e procure por Aspose.Font e instale. Você também pode usar o seguinte comando no console do gerenciador de pacotes.

Package Manager Console Command


    PM> Install-Package Aspose.Font

Etapas para calcular a largura da string usando C++:

Para calcular a largura de uma string usando glifos, você precisa primeiro determinar a largura de cada glifo individual na string e, em seguida, somar essas larguras para obter o número total. Se explicar com etapas, a ordem é a seguinte:

  1. Determine a fonte e o tamanho que deseja usar para calcular a largura da string.
  2. Para cada caractere na string, determine o glifo correspondente na fonte. Use o mapa de caracteres, que fornecerá o índice do glifo correspondente.
  3. Usando o índice de glifo, procure as métricas do glifo na tabela de métricas da fonte. As métricas para um glifo normalmente incluem sua largura, altura e largura de avanço.
  4. Some as larguras avançadas de todos os glifos na string para obter a largura total da string. Observe para prestar atenção às informações de kerning.

Se descrevesse um processo semelhante com o código C++, seria o seguinte.

Código C++ para descobrir a largura da string

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

Etapas para calcular todos os pontos de glifo com coordenadas usando C++:

  1. Declare a lista points do tipo System::Drawing::Point: Esta lista armazenará os pontos de um segmento de caminho glifo..
  2. Especifique a referência do serviço Init na interface IPathSegment .
  3. Repita todos os segmentos do caminho do glifo e some os pontos.

Código C++ para descobrir pontos de glifo

    //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;
    }



Perguntas frequentes

1. O que é uma métrica de glifo?

Métricas de glifo são os parâmetros que influenciam como o glifo é posicionado quando o layout de texto é criado.

2. O que são métricas de glifos?

As métricas de glifo mais usadas são largura de avanço, origem, rolamentos laterais, linha de base, subida, subida, descida, descida, caixa delimitadora, altura, largura e kerning.

3. Como gerenciar glifos com esta solução de API?

Para codificar glifos em C#, use as entidades do namespace Aspose.Font.Glyphs .

4. Qual é a importância das métricas de glifo?

Ao compreender e ajustar adequadamente as métricas de glifos, tipógrafos e designers podem garantir espaçamento, alinhamento e legibilidade ideais do texto em materiais impressos, interfaces digitais ou páginas da web.