Renderizar texto usando glifos

Solución API C++. para mostrar texto con la fuente deseada.

Aspose.Font API Solution ofrece amplias capacidades para trabajar con fuentes, incluyendo conversión, manipulación de glifos, detección de símbolos latinos y más. Algunas de las funciones están relacionadas con la manipulación de glifos, como la renderización de texto.

Un glifo es un diseño único de un carácter en una tipografía o una representación gráfica de un símbolo o carácter. Para obtener una comprensión más profunda de esta unidad tipográfica, lea el artículo Introducción a los Glifos .

Esta página explica cómo mostrar texto usando glifos, pero una explicación completa de la funcionalidad se proporciona en el artículo Uso de objetos Glifo . Allí encontrará más ejemplos de código C++ y aprenderá sobre las capacidades de Aspose.Font para trabajar con glifos y objetos Glifo específicamente. También puede consultar ejemplos completos y archivos de datos en el Proyecto Github de Aspose.

Para escribir textos con glifos necesitamos:

Aspose.Font para C++ API, que es una API con muchas funciones, 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

Renderizar texto con glifos usando C++

Los siguientes pasos suelen ser necesarios para renderizar texto con los glifos:

Cargue el archivo de fuente en memoria. Aquí necesita crear un objeto de fuente, como un objeto Type1Font, y pasar la ruta del archivo de fuente.
Decodifique el texto en sus correspondientes IDs de glifo. Para ello, pase cada carácter del texto a través del objeto de codificación de la fuente y decodifíquelo a su correspondiente ID de glifo.
Obtenga el contorno de cada glifo. El contorno es una ruta que define la forma del carácter. Esto se puede lograr usando el método GetGlyphOutline() del objeto Font .
Dibuje los contornos de cada glifo usando un objeto gráfico, como un objeto GraphicsPath. Simplemente cree un objeto que implemente la interfaz IGlyphOutlinePainter, que es responsable de dibujar los contornos de los glifos.
Muestre el texto usando un objeto gráfico para dibujar los contornos de cada glifo. Esto se puede hacer usando el método DrawPath() del objeto gráfico.

Código C++ para renderizar texto

    using Aspose::Font::Glyphs;
    using Aspose::Font::Rendering;
    using Aspose::Font::RenderingPath;

    class GlyphOutlinePainter: IGlyphOutlinePainter
    RenderingText::GlyphOutlinePainter::GlyphOutlinePainter(System::SharedPtr<System::Drawing::Drawing2D::GraphicsPath> path)
    {
        _path = path;
    }

    void RenderingText::GlyphOutlinePainter::MoveTo(System::SharedPtr<Aspose::Font::RenderingPath::MoveTo> moveTo)
    {
        _path->CloseFigure();
        _currentPoint.set_X((float)moveTo->get_X());
        _currentPoint.set_Y((float)moveTo->get_Y());
    }

    void RenderingText::GlyphOutlinePainter::LineTo(System::SharedPtr<Aspose::Font::RenderingPath::LineTo> lineTo)
    {
        float x = (float)lineTo->get_X();
        float y = (float)lineTo->get_Y();
        _path->AddLine(_currentPoint.get_X(), _currentPoint.get_Y(), x, y);
        _currentPoint.set_X(x);
        _currentPoint.set_Y(y);
    }

    void RenderingText::GlyphOutlinePainter::CurveTo(System::SharedPtr<Aspose::Font::RenderingPath::CurveTo> curveTo)
    {
        float x3 = (float)curveTo->get_X3();
        float y3 = (float)curveTo->get_Y3();
    
        _path->AddBezier(_currentPoint.get_X(), _currentPoint.get_Y(), (float)curveTo->get_X1(), (float)curveTo->get_Y1(), (float)curveTo->get_X2(), (float)curveTo->get_Y2(), x3, y3);
    
        _currentPoint.set_X(x3);
        _currentPoint.set_Y(y3);
    }

    void RenderingText::GlyphOutlinePainter::ClosePath()
    {
        _path->CloseFigure();
    }

    System::Object::shared_members_type Aspose::Font::Examples::WorkingWithTrueTypeAndOpenTypeFonts::RenderingText::GlyphOutlinePainter::GetSharedMembers()
    {
        auto result = System::Object::GetSharedMembers();
    
        result.Add("Aspose::Font::Examples::WorkingWithTrueTypeAndOpenTypeFonts::RenderingText::GlyphOutlinePainter::_path", this->_path);
        result.Add("Aspose::Font::Examples::WorkingWithTrueTypeAndOpenTypeFonts::RenderingText::GlyphOutlinePainter::_currentPoint", this->_currentPoint);
    
        return result;
    }

Preguntas más frecuentes

1. ¿Cómo se representa la fuente mediante Aspose.Font?

Para representar fuentes usando esta solución API necesitarás las entidades de Aspose.Font.Rendering y Aspose.Font.Renderers espacios de nombres. Primero, implemente los métodos IGlyphOutlinePainter. Luego cree el método DrawText(). Cree el método de utilidad para calcular el ancho de fuente y llame a la funcionalidad de representación de texto.

2. ¿A qué factores debería prestar atención al representar texto con glifos?

Al representar texto con glifos, hay varios factores importantes a considerar para garantizar resultados precisos y visualmente atractivos, como selección de fuente, sugerencias, interletraje y seguimiento, métricas de glifos, color y contraste, etc.

3. ¿Qué es la sugerencia de fuente?

Las sugerencias pueden ayudar a mantener la claridad y legibilidad del texto, especialmente en tamaños más pequeños o en pantallas de baja resolución.