Representación de texto usando fuente Type1 | C++

Representación de texto

Para representar texto, el subsistema de Renderizado requiere la implementación de la interfaz Aspose.Font.Rendering.IGlyphOutlinePainter para dibujar glifos. Esto se puede lograr mediante los siguientes pasos.

1. Implemente los métodos IGlyphOutlinePainter creando una clase GlyphOutlinePainter que requiere un objeto de tipo System.Drawing.Drawing2D.GraphicsPath para los objetivos de dibujo gráfico. La implementación es como se ilustra a continuación.

For complete examples and data files, please go to https://github.com/aspose-font/Aspose.Font-for-C
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::WorkingWithType1Fonts::RenderingText::GlyphOutlinePainter::GetSharedMembers()
{
    auto result = System::Object::GetSharedMembers();
    
    result.Add("Aspose::Font::Examples::WorkingWithType1Fonts::RenderingText::GlyphOutlinePainter::_path", this->_path);
    result.Add("Aspose::Font::Examples::WorkingWithType1Fonts::RenderingText::GlyphOutlinePainter::_currentPoint", this->_currentPoint);
    
    return result;
}

2. Cree el método DrawText() que dibuja el texto especificado en el objeto System.Drawing.Bitmap y guarda el mapa de bits resultante en el disco. Esto incluirá los siguientes pasos:

• Iterar todos los símbolos en la cadena de texto.
• Obtenga un identificador de glifo para cada símbolo procesado: gid.
• Crear un objeto de tipo GlyphOutlinePainter que es requerido por el subsistema de representación para dibujar el glifo actual.
• Cree un objeto de tipo Aspose.Font.Renderers.GlyphOutlineRenderer y pase el objeto recién creado de tipo GlyphOutlinePainter al constructor de GlyphOutlineRenderer. Este objeto GlyphOutlineRenderer tenía como objetivo representar el glifo especificado.
• Renderiza el glifo procesado actual usando el método GlyphOutlineRenderer.RenderGlyph(). El objeto Aspose.Fonts.Matrix se utiliza para especificar las coordenadas del glifo. El glifo a renderizar se especifica mediante el parámetro gid.

Pasos auxiliares para esta estrategia

• La coordenada del glifo para el eje ‘Y’ es constante para este fragmento de código.
• La coordenada de glifo para el eje ‘X’ se calcula para cada glifo procesado.
• Tanto las coordenadas ‘X’ como ‘Y’ se pasan al objeto Aspose.Fonts.Matrix que utiliza GlyphOutlineRenderer para dibujar glifos.
• La distancia entre los glifos recién procesados ​​y los anteriores se calcula en cada paso de iteración. Esta distancia afecta a cada coordenada ‘X’ de glifo.
• El objeto de tipo GlyphOutlinePainter dibuja glifos con la ayuda de GlyphOutlinePainter no directamente en Bitmap, sino en el objeto GraphicsPath, que se pasó al constructor de GlyphOutlinePainter, por lo que usamos el objeto de tipo System.Drawing.Graphics para dibujar GraphicsPath en Bitmap.
• Método FontWidthToImageWith() que calcula el ancho del glifo para el sistema de coordenadas de mapa de bits.

La implementación del método DrawText se muestra a continuación.

For complete examples and data files, please go to https://github.com/aspose-font/Aspose.Font-for-C
void RenderingText::DrawText(System::String text, System::SharedPtr<IFont> font, double fontSize, System::SharedPtr<System::Drawing::Brush> backgroundBrush, System::SharedPtr<System::Drawing::Brush> textBrush, System::String outFile)
{
    //Get glyph identifiers for every symbol in text line
    System::ArrayPtr<System::SharedPtr<GlyphId>> gids = System::MakeArray<System::SharedPtr<Aspose::Font::Glyphs::GlyphId>>(text.get_Length());
    for (int32_t i = 0; i < text.get_Length(); i++)
    {
        gids[i] = font->get_Encoding()->DecodeToGid(text[i]);
    }
    // set common drawing settings
    double dpi = 300;
    
    double resolutionCorrection = dpi / 72;
    // 72 is font's internal dpi
    // prepare output bitmap
    System::SharedPtr<System::Drawing::Bitmap> outBitmap = System::MakeObject<System::Drawing::Bitmap>(960, 720);
    outBitmap->SetResolution((float)dpi, (float)dpi);
    System::SharedPtr<System::Drawing::Graphics> outGraphics = System::Drawing::Graphics::FromImage(outBitmap);
    outGraphics->FillRectangle(backgroundBrush, 0, 0, outBitmap->get_Width(), outBitmap->get_Height());
    outGraphics->set_SmoothingMode(System::Drawing::Drawing2D::SmoothingMode::HighQuality);
    //declare coordinate variables and previous gid
    System::SharedPtr<GlyphId> previousGid;
    double glyphXCoordinate = 0;
    double glyphYCoordinate = fontSize * resolutionCorrection;
    //loop which paints every glyph in gids
    
    {
        for (System::SharedPtr<GlyphId> gid : gids)
        {
            // if the font contains the gid
            if (gid != nullptr)
            {
                System::SharedPtr<Glyph> glyph = font->get_GlyphAccessor()->GetGlyphById(gid);
                if (glyph == nullptr)
                {
                    continue;
                }
                
                // path that accepts drawing instructions
                System::SharedPtr<System::Drawing::Drawing2D::GraphicsPath> path = System::MakeObject<System::Drawing::Drawing2D::GraphicsPath>();
                
                // Create IGlyphOutlinePainter implementation
                System::SharedPtr<RenderingText::GlyphOutlinePainter> outlinePainter = System::MakeObject<RenderingText::GlyphOutlinePainter>(path);
                
                // Create the renderer
                System::SharedPtr<Aspose::Font::Renderers::IGlyphRenderer> renderer = System::MakeObject<Aspose::Font::Renderers::GlyphOutlineRenderer>(outlinePainter);
                
                // get common glyph properties
                double kerning = 0;
                
                // get kerning value
                if (previousGid != nullptr)
                {
                    kerning = (font->get_Metrics()->GetKerningValue(previousGid, gid) / glyph->get_SourceResolution()) * fontSize * resolutionCorrection;
                    kerning += FontWidthToImageWith(font->get_Metrics()->GetGlyphWidth(previousGid), glyph->get_SourceResolution(), fontSize);
                }
                
                // glyph positioning - increase glyph X coordinate according to kerning distance
                glyphXCoordinate += kerning;
                
                // Glyph placement matrix
                System::SharedPtr<TransformationMatrix> glyphMatrix = System::MakeObject<TransformationMatrix>(System::MakeArray<double>({fontSize * resolutionCorrection, 0, 0, -fontSize * resolutionCorrection, glyphXCoordinate, glyphYCoordinate}));
                
                // render current glyph
                renderer->RenderGlyph(font, gid, glyphMatrix);
                // fill the path
                path->set_FillMode(System::Drawing::Drawing2D::FillMode::Winding);
                outGraphics->FillPath(textBrush, path);
            }
            //set current gid as previous to get correct kerning for next glyph
            previousGid = gid;
        }
        
    }
    //Save results
    outBitmap->Save(outFile);
}

3. Cree un método de utilidad para calcular el ancho de la fuente con respecto al ancho de la imagen como se muestra en el ejemplo de código a continuación.

For complete examples and data files, please go to https://github.com/aspose-font/Aspose.Font-for-C
double RenderingText::FontWidthToImageWith(double width, int32_t fontSourceResulution, double fontSize, double dpi /* = 300*/)
{
    double resolutionCorrection = dpi / 72;
    // 72 is font's internal dpi
    return (width / fontSourceResulution) * fontSize * resolutionCorrection;
}

Llamar a la funcionalidad de renderizado de texto

Para utilizar las implementaciones anteriores, se puede ejecutar el siguiente código de muestra desde el método Main de una aplicación basada en consola.

For complete examples and data files, please go to https://github.com/aspose-font/Aspose.Font-for-C
System::String fileName = dataDir + u"courier.pfb";
//Font file name with full path
    
System::SharedPtr<FontDefinition> fd = System::MakeObject<FontDefinition>(Aspose::Font::FontType::Type1, System::MakeObject<FontFileDefinition>(u"pfb", System::MakeObject<FileSystemStreamSource>(fileName)));
System::SharedPtr<Type1Font> font = System::DynamicCast_noexcept<Aspose::Font::Type1::Type1Font>(Aspose::Font::Font::Open(fd));
    
    
DrawText(u"Hello world", font, 14, System::Drawing::Brushes::get_White(), System::Drawing::Brushes::get_Black(), dataDir + u"hello1_type1_out.jpg");
DrawText(u"Hello world", font, 14, System::Drawing::Brushes::get_Yellow(), System::Drawing::Brushes::get_Red(), dataDir + u"hello2_type1_out.jpg");