Leer información de glifos y métricas

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

 

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

  Nuget   Pricing Buy
 

Aspose.Font API ofrece una gama completa de funciones relacionadas con fuentes, incluida la conversión, la manipulación de glifos, la detección de símbolos latinos y más. Algunas de estas características se refieren a la manipulación de glifos, que son caracteres individuales de una tipografía o representaciones gráficas de símbolos/caracteres. Para comprender más sobre estas unidades de una fuente, consulte el artículo Introduction to 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. Más ejemplos de código que demuestran el uso de Aspose.Font para manipular glifos pueden encontrarse en el proyecto de Aspose Github Project .

Las métricas de glifos, el término usado aquí, se refieren a la información y medidas de un glifo particular en una fuente. Pueden incluir datos como la altura, anchura, ancho de avance y otras dimensiones de un glifo, que son importantes para el posicionamiento y espaciado adecuados de los caracteres en una fuente. Estas métricas son utilizadas por los sistemas de diseño y renderizado de texto para asegurar una visualización coherente y precisa del texto.

Para trabajar con glifos necesitamos:

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

  • Abra el administrador de paquetes NuGet, 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 necesita determinar el ancho de cada glifo individual en la cadena y luego sumar esos anchos para obtener el número total. Si se explica 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 en la cadena, determine el glifo correspondiente en la fuente. Use el mapa de caracteres, que le dará el índice del glifo correspondiente.
  3. Usando el índice del glifo, busque las métricas del glifo en la tabla de métricas de la fuente. Las métricas de un glifo típicamente incluyen su ancho, altura y ancho de avance.
  4. Sume los anchos avanzados de todos los glifos en la cadena para obtener el ancho total de la cadena. Preste atención a la información de kerning.

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

Código C++ para determinar 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 los glifos con coordenadas usando C++:

  1. Declare la lista points de tipo System::Drawing::Point: Esta lista almacenará los puntos de un segmento de ruta de glifo.
  2. Especifique la referencia al servicio Init en la interfaz IPathSegment .
  3. Itere todos los segmentos de ruta de glifos y sume los puntos.

Código C++ para determinar los puntos de los glifos

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