Text Rendering using Type1 Font | .NET

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-.NET
    class GlyphOutlinePainter : IGlyphOutlinePainter
    { 
        private System.Drawing.Drawing2D.GraphicsPath _path;
        private System.Drawing.PointF _currentPoint;
    
        public GlyphOutlinePainter(System.Drawing.Drawing2D.GraphicsPath path)
        {
            _path = path;
        }
    
        public void MoveTo(MoveTo moveTo)
        {
            _path.CloseFigure();
            _currentPoint.X = (float)moveTo.X;
            _currentPoint.Y = (float)moveTo.Y;
        }
    
        public void LineTo(LineTo lineTo)
        {
            float x = (float)lineTo.X;
            float y = (float)lineTo.Y;
            _path.AddLine(_currentPoint.X, _currentPoint.Y, x, y);
            _currentPoint.X = x;
            _currentPoint.Y = y;
        }
    
        public void CurveTo(CurveTo curveTo)
        {
            float x3 = (float)curveTo.X3;
            float y3 = (float)curveTo.Y3;
    
            _path.AddBezier(
                      _currentPoint.X,
                      _currentPoint.Y,
                      (float)curveTo.X1,
                      (float)curveTo.Y1,
                      (float)curveTo.X2,
                      (float)curveTo.Y2,
                      x3,
                      y3);
    
            _currentPoint.X = x3;
            _currentPoint.Y = y3;
        }
    
        public void ClosePath()
        {
            _path.CloseFigure();
        }
    }

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-.NET
 static void DrawText(string text, IFont font, double fontSize,
             Brush backgroundBrush, Brush textBrush, string outFile)
 {
     //Get glyph identifiers for every symbol in text line
     GlyphId[] gids = new GlyphId[text.Length];
     for (int i = 0; i < text.Length; i++)
         gids[i] = font.Encoding.DecodeToGid(text[i]);
     // set common drawing settings
     double dpi = 300;
 
     double resolutionCorrection = dpi / 72; // 72 is font's internal dpi
     // prepare output bitmap
     Bitmap outBitmap = new Bitmap(960, 720);
     outBitmap.SetResolution((float)dpi, (float)dpi);
     Graphics outGraphics = Graphics.FromImage(outBitmap);
     outGraphics.FillRectangle(backgroundBrush, 0, 0, outBitmap.Width, outBitmap.Height);
     outGraphics.SmoothingMode = SmoothingMode.HighQuality;
     //declare coordinate variables and previous gid
     GlyphId previousGid = null;
     double glyphXCoordinate = 0;
     double glyphYCoordinate = fontSize * resolutionCorrection;
     //loop which paints every glyph in gids
     foreach (GlyphId gid in gids)
     {
         // if the font contains the gid
         if (gid != null)
         {
             Glyph glyph = font.GlyphAccessor.GetGlyphById(gid);
             if (glyph == null)
                 continue;
 
             // path that accepts drawing instructions
             GraphicsPath path = new GraphicsPath();
 
             // Create IGlyphOutlinePainter implementation
             GlyphOutlinePainter outlinePainter = new GlyphOutlinePainter(path);
 
             // Create the renderer
             Aspose.Font.Renderers.IGlyphRenderer renderer = new
                 Aspose.Font.Renderers.GlyphOutlineRenderer(outlinePainter);
 
             // get common glyph properties
             double kerning = 0;
 
             // get kerning value
             if (previousGid != null)
             {
                 kerning = (font.Metrics.GetKerningValue(previousGid, gid) /
                            glyph.SourceResolution) * fontSize * resolutionCorrection;
                 kerning += FontWidthToImageWith(font.Metrics.GetGlyphWidth(previousGid),
                         glyph.SourceResolution, fontSize);
             }
 
             // glyph positioning - increase glyph X coordinate according to kerning distance
             glyphXCoordinate += kerning;
 
             // Glyph placement matrix
             TransformationMatrix glyphMatrix =
                 new TransformationMatrix(
                     new double[]
                             {
                                     fontSize*resolutionCorrection,
                                     0,
                                     0,
                                 // negative because of bitmap coordinate system begins from the top
                                     - fontSize*resolutionCorrection,
                                     glyphXCoordinate,
                                     glyphYCoordinate
                             });
 
             // render current glyph
             renderer.RenderGlyph(font, gid, glyphMatrix);
             // fill the path
             path.FillMode = 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-.NET
     static double FontWidthToImageWith(double width, int 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 implementations, 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-.NET
string fileName = dataDir + "courier.pfb"; //Font file name with full path

FontDefinition fd = new FontDefinition(FontType.Type1, new FontFileDefinition("pfb", new FileSystemStreamSource(fileName)));
Type1Font font = Aspose.Font.Font.Open(fd) as Type1Font;
            

DrawText("Hello world", font, 14, Brushes.White, Brushes.Black, dataDir + "hello1_type1_out.jpg");
DrawText("Hello world", font, 14, Brushes.Yellow, Brushes.Red, dataDir + "hello2_type1_out.jpg");