Leer información de glifos y métricas

Solución API de C++ para calcular el ancho de la cadena, calcular las coordenadas de los glifos y otras manipulaciones con glifos.

 

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

  Nuget   Pricing Buy
 

Aspose.Font API ofrece una amplia gama de funciones relacionadas con fuentes, que incluyen conversión, manipulación de glifos, detección de símbolos latinos y más. Algunas de estas características pertenecen a la manipulación de glifos, que son caracteres individuales de un tipo de letra o representaciones gráficas de símbolos/caracteres. Para comprender más acerca de estas unidades de una fuente, consulte el artículo Introducción a Glyph .

Esta página describe la opción para leer información de glifos y métricas, pero para una comprensión completa de la funcionalidad, consulte el artículo Using Glyph Objects Aquí encontrará numerosos ejemplos de código C++ y aprenderá sobre las capacidades de Aspose.Font para trabajar con glifos y objetos Glyph. Se pueden encontrar más ejemplos de código que demuestran el uso de Aspose.Font para manipular glifos en Aspose Github Project .

Métricas de glifo, el término utilizado aquí, se refiere a la información y las medidas de un glifo en particular en una fuente. Pueden incluir información como la altura, el ancho, el ancho de avance y otras dimensiones de un glifo, que son importantes para la posición y el espaciado adecuados de los caracteres en una fuente. Estas métricas son utilizadas por los sistemas de representación y diseño de texto para garantizar una visualización coherente y precisa del texto.

Para trabajar con glifos necesitamos:

  • Aspose.Font para la API de C++, que es una API de manipulación y conversión de documentos rica en funciones, potente y fácil de usar.

  • Abra el administrador de paquetes NuGet y busque Aspose.Font e instálelo. También puede usar el siguiente comando desde la Consola del administrador de paquetes.

Package Manager Console Command


    PM> Install-Package Aspose.Font

Pasos para calcular el ancho de la cadena usando C++:

Para calcular el ancho de una cadena usando glifos, primero debe determinar el ancho de cada glifo individual en la cadena y luego sumar esos anchos para obtener el número total. Si lo explicas con pasos el orden es el siguiente:

  1. Determine la fuente y el tamaño que desea usar para calcular el ancho de la cadena.
  2. Para cada carácter de la cadena, determine el glifo correspondiente en la fuente. Utilice el mapa de caracteres, que le dará el índice del glifo correspondiente.
  3. Con el índice de glifos, busque las métricas del glifo en la tabla de métricas de la fuente. Las medidas de un glifo generalmente incluirán su ancho, alto y ancho de avance.
  4. Sume los anchos avanzados de todos los glifos de la cadena para obtener el ancho total de la cadena. Tenga en cuenta que debe prestar atención a la información de interletraje.

Si describiera un proceso similar con el código C++, se vería de la siguiente manera.

Código C++ para averiguar el ancho de la cadena

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

Pasos para calcular todos los puntos de glifo con coordenadas usando C++:

  1. Declarar la lista puntos de tipo Sistema::Dibujo::Punto: Esta lista almacenará los puntos de un segmento de ruta de glifo..
  2. Especifique la referencia del servicio Init en la interfaz IPathSegment .
  3. Repita todos los segmentos de ruta de glifo y sume los puntos.

Código C++ para encontrar puntos 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;
    }



Preguntas más frecuentes

1. ¿Qué es una métrica de glifo?

Glyph metrics son los parámetros que influyen en cómo se coloca el glifo cuando se crea el diseño del texto.

2. ¿Qué son las métricas de glifos?

Las métricas de glifo más utilizadas son el ancho de avance, el origen, los rumbos laterales, la línea de base, el ascenso, el ascendente, el descendente, el descendente, el cuadro delimitador, la altura, el ancho y el interletraje.

3. ¿Cómo administrar Glyphs con esta solución API?

Para codificar glifos en C#, use las entidades del espacio de nombres Aspose.Font.Glyphs .

4. ¿Cuál es la importancia de las métricas de glifos?

Al comprender y ajustar adecuadamente las métricas de glifos, los tipógrafos y diseñadores pueden garantizar un espaciado, alineación y legibilidad óptimos del texto en materiales impresos, interfaces digitales o páginas web.