Leer información de fuentes

Explore las métricas de fuentes con la solución API Aspose.Font para C++. Conozca información detallada sobre cada trazo, curva y matiz. Nuestra solución le permite trabajar sin esfuerzo con glifos, permitiéndole extraer información sobre las características únicas de cualquier fuente.

 

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

  Nuget   Pricing Buy
 

Sumérjase en un mundo de posibilidades de fuentes con la solución API Aspose.Font para C++, que le ofrece un conjunto de potentes funciones, que incluyen conversiones de fuentes, manipulación de glifos, detección de símbolos latinos y más. Nuestra API también le permite trabajar con glifos y obtener información sobre los glifos incluidos en una fuente. Mejore sus diseños, potencie sus proyectos y libere todo el potencial de los glifos con Aspose.Font para C++. ¡No esperes y obtén una prueba gratuita!

Un glifo es un diseño único para un carácter o símbolo en un tipo de letra. Para comprender mejor esta unidad de fuente, lea el artículo Introducción a Glyph . Las métricas de fuente son medidas y especificaciones utilizadas para describir la apariencia visual de un tipo de letra. Estas métricas pueden incluir información como la altura de los caracteres, el ancho de los caracteres, el espacio entre caracteres y la posición de la línea de base, entre otros. Permiten a los diseñadores y desarrolladores de software predecir con precisión el diseño del texto en documentos digitales e interfaces de usuario.

Esta página explica cómo recuperar diferentes métricas de fuentes, como la cantidad de glifos, la altura de las letras, el ancho del glifo ‘A’, etc. Sin embargo, la funcionalidad completa de trabajar con glifos se describe en detalle en el artículo Uso de objetos Glyph. El ejemplo de código incluye una sección sobre la recuperación de metadatos de fuentes, incluido el nombre de la fuente. Este tipo de funcionalidad se puede integrar en aplicaciones web, como la aplicación Font Metadata disponible en el ecosistema de Aspose. Si desea obtener ejemplos completos y archivos de datos, vaya a Aspose Github Project .

Para recibir métricas de fuentes 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 obtener métricas de fuentes usando C++:

  1. Extrae información sobre una fuente creando una instancia de la clase TtfFont .
  2. Imprime el nombre de la fuente usando la propiedad FontName.
  3. Imprime el número de glifos en la fuente usando la propiedad NumGlyphs. También se imprimen las métricas de la fuente, como ascendente, descendente, ascendente de error tipográfico, descendente de error tipográfico y UnitsPerEm.
  4. Luego, el código recupera la tabla de codificación Unicode cmap de la fuente, que se utiliza para asignar códigos de caracteres a índices de glifos. Comprueba si la fuente tiene tanto la tabla cmap como la tabla glyf, que se utiliza para acceder a los glifos. Si ambas tablas están presentes, recupera el índice glyf para el carácter A y luego obtiene el glifo para el símbolo A.
  5. Imprime el cuadro delimitador del glifo A y su ancho.

Código C++ para obtener información sobre los glifos de la fuente

    using Aspose::Font;
    using Aspose::Font::Glyphs;
    using Aspose::Font::Ttf;
    //Font file name with the full path
    
    System::SharedPtr<FontDefinition> fd = System::MakeObject<FontDefinition>(Aspose::Font::FontType::TTF, System::MakeObject<FontFileDefinition>(u"ttf", System::MakeObject<FileSystemStreamSource>(fileName)));
    System::SharedPtr<TtfFont> font = System::DynamicCast_noexcept<Aspose::Font::Ttf::TtfFont>(Aspose::Font::Font::Open(fd));
    
    System::String name = font->get_FontName();
    System::Console::WriteLine(System::String(u"Font name: ") + name);
    System::Console::WriteLine(System::String(u"Glyph count: ") + font->get_NumGlyphs());
    System::String metrics = System::String::Format(u"Font metrics: ascender - {0}, descender - {1}, typo ascender = {2}, typo descender = {3}, UnitsPerEm = {4}", font->get_Metrics()->get_Ascender(), font->get_Metrics()->get_Descender(), font->get_Metrics()->get_TypoAscender(), font->get_Metrics()->get_TypoDescender(), font->get_Metrics()->get_UnitsPerEM());
    
    System::Console::WriteLine(metrics);
    
    //Get cmap unicode encoding table from the font as object TtfCMapFormatBaseTable to access the information about the font glyph for symbol 'A'.
    //Also check that font has object TtfGlyfTable (table 'glyf') to access glyph.
    System::SharedPtr<Aspose::Font::TtfCMapFormats::TtfCMapFormatBaseTable> cmapTable;
    if (font->get_TtfTables()->get_CMapTable() != nullptr)
    {
        cmapTable = font->get_TtfTables()->get_CMapTable()->FindUnicodeTable();
    }
    if (cmapTable != nullptr && font->get_TtfTables()->get_GlyfTable() != nullptr)
    {
        System::Console::WriteLine(System::String(u"Font cmap unicode table: PlatformID = ") + cmapTable->get_PlatformId() + u", PlatformSpecificID = " + cmapTable->get_PlatformSpecificId());
    
        //Code for 'A' symbol
        char16_t unicode = (char16_t)65;
    
        //Glyph index for 'A'
        uint32_t glIndex = cmapTable->GetGlyphIndex(unicode);
    
        if (glIndex != static_cast<uint32_t>(0))
        {
            //Glyph for 'A'
            System::SharedPtr<Glyph> glyph = font->GetGlyphById(glIndex);
            if (glyph != nullptr)
            {
                //Print glyph metrics
                System::Console::WriteLine(u"Glyph metrics for 'A' symbol:");
                System::String bbox = System::String::Format(System::String(u"Glyph BBox: Xmin = {0}, Xmax = {1}") + u", Ymin = {2}, Ymax = {3}", glyph->get_GlyphBBox()->get_XMin(), glyph->get_GlyphBBox()->get_XMax(), glyph->get_GlyphBBox()->get_YMin(), glyph->get_GlyphBBox()->get_YMax());
                System::Console::WriteLine(bbox);
                System::Console::WriteLine(System::String(u"Width:") + font->get_Metrics()->GetGlyphWidth(System::MakeObject<GlyphUInt32Id>(glIndex)));
            }
        }
    }



Preguntas más frecuentes

1. ¿Cuál es la métrica de la fuente?

Es la propiedad que determina la forma en que la fuente se representará en la pantalla. Algunas de las métricas, como el ascenso, el descenso, el ancho y el kerning, son similares a Glyph metrics .

2. ¿Cómo obtengo métricas de fuentes?

Especifique la fuente con la que desea trabajar. Usando las propiedades de la interfaz de clase Aspose.Font.IFontMetrics, extraiga la información sobre las métricas de fuente que necesita.

3. ¿Qué son los metadatos de fuentes?

Los metadatos de fuentes son básicamente información al respecto. Incluye muchos datos como el nombre de la fuente, el nombre de la familia de fuentes, el nombre de Postscript, la licencia, la información del autor y del diseñador, y mucho más.

4. ¿Cómo cambio los metadatos de la fuente?

Para ver o cambiar la información de fuentes en línea, use nuestra aplicación Font Metadata .