Text Rendering using Type1 Font | C++

Rendering Text

In order to render text, the Rendering subsystem requires the implementation of Aspose.Font.Rendering.IGlyphOutlinePainter interface to draw glyph. This can be achieved using the following steps.

1. Implement the IGlyphOutlinePainter methods by creating a class GlyphOutlinePainter which requires object of type System.Drawing.Drawing2D.GraphicsPath for graphic drawing objectives. The implementation is as illustrated below.

   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. Create method DrawText() which draws specified text into System.Drawing.Bitmap object and saves resultant bitmap on Disc. This will include the following steps:

• Iterate all symbols in text string.
• Get glyph identifier for every processed symbol - gid.
• Create object of type GlyphOutlinePainter which is required by rendering subsystem to draw current glyph.
• Create object of type Aspose.Font.Renderers.GlyphOutlineRenderer, and pass just created object of type GlyphOutlinePainter into constructor for GlyphOutlineRenderer. This object GlyphOutlineRenderer intended to render specified glyph.
• Render current processed glyph using method GlyphOutlineRenderer.RenderGlyph(). Aspose.Fonts.Matrix object is used to specify glyph coordinates. Glyph to render is specified by gid parameter.

Auxillary steps for this strategy

• Glyph coordinate for ‘Y’ axis is constant for this code snippet.
• Glyph coordinate for ‘X’ axis is calculated for every processed glyph.
• Both ‘X’ and ‘Y’ coordinates are passed into object Aspose.Fonts.Matrix which is used by GlyphOutlineRenderer to draw glyph.
• Distance between just processed and previous glyphs is calculated on every iteration step. This distance affects every glyph ‘X’ coordinate.
• Object of type GlyphOutlinePainter draws glyph with the help of GlyphOutlinePainter not into Bitmap directly, but into object GraphicsPath, which was passed into constructor for GlyphOutlinePainter, so we use object of type System.Drawing.Graphics to draw GraphicsPath into Bitmap.
• Method FontWidthToImageWith() which calculates glyph width for bitmap coordinate system.

Implementation of DrawText method is as shown below.

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

1. create utility method to calculate font width to image width as shown in the code sample below

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

Calling the Rendering Text functionality

To use the above implmentations, the following sample code can be executed from the Main method of a console based application.

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