Text Rendering using TrueType Font | Java

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. 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-Java
 static void drawText(String text, IFont font, double fontSize,
            Paint backgroundBrush, Paint textBrush, String outFile) throws Exception
 {
     //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.getEncoding().decodeToGid(text.charAt(i));
     // set common drawing settings
     double dpi = 300;
 	
     double resolutionCorrection = dpi / 72; // 72 is font's internal dpi
     // prepare output bitmap
     BufferedImage outBitmap = new BufferedImage(960, 720, BufferedImage.TYPE_INT_BGR);
     //outBitmap.getRaster().SetResolution((float)dpi, (float)dpi);
     java.awt.Graphics2D outGraphics = (java.awt.Graphics2D) outBitmap.getGraphics();
     outGraphics.setPaint(backgroundBrush);
     outGraphics.fillRect(0, 0, outBitmap.getWidth(), outBitmap.getHeight());
     outGraphics.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
     //declare coordinate variables and previous gid
     GlyphId previousGid = null;
     double glyphXCoordinate = 0;
     double glyphYCoordinate = fontSize * resolutionCorrection;
     //loop which paints every glyph in gids
     for (GlyphId gid : gids)
     {
         // if the font contains the gid
         if (gid != null)
         {
             Glyph glyph = font.getGlyphAccessor().getGlyphById(gid);
             if (glyph == null)
                 continue;
 	
             // path that accepts drawing instructions
             GeneralPath path = new GeneralPath();
 	
             // Create IGlyphOutlinePainter implementation
             GlyphOutlinePainter outlinePainter = new GlyphOutlinePainter(path);
 	
             // Create the renderer
             IGlyphRenderer renderer = new GlyphOutlineRenderer(outlinePainter);
 	
             // get common glyph properties
             double kerning = 0;
 	
             // get kerning value
             if (previousGid != null)
             {
                 kerning = (font.getMetrics().getKerningValue(previousGid, gid) /
                            glyph.getSourceResolution()) * fontSize * resolutionCorrection;
                 kerning += fontWidthToImageWdith(font.getMetrics().getGlyphWidth(previousGid),
                         glyph.getSourceResolution(), fontSize, 300);
             }
 	
             // 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.setWindingRule(GeneralPath.WIND_NON_ZERO);
             outGraphics.setPaint(textBrush);
             outGraphics.fill(path);
         }
         //set current gid as previous to get correct kerning for next glyph
         previousGid = gid;
     }
     //Save results
     ImageIO.write(outBitmap, "jpg", new File(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-Java
     static double fontWidthToImageWidth(double width, int fontSourceResulution, double fontSize, double dpi)
     {
         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-Java
String fileName1 = Utils.getDataDir() + "Montserrat-Bold.ttf"; //Font file name with full path
      FontDefinition fd1 = new FontDefinition(FontType.TTF, new FontFileDefinition("ttf", new FileSystemStreamSource(fileName1)));
      TtfFont font1 = (TtfFont) Font.open(fd1);
      
      String fileName2 = Utils.getDataDir() + "Lora-Bold.ttf"; //Font file name with full path
      FontDefinition fd2 = new FontDefinition(FontType.TTF, new FontFileDefinition("ttf", new FileSystemStreamSource(fileName2)));
      TtfFont font2 = (TtfFont) Font.open(fd2);
      
      try {
       drawText("Hello world", font1, 14, java.awt.Color.WHITE, java.awt.Color.BLACK, Utils.getDataDir() + "hello1_montserrat_out.jpg");
       drawText("Hello world", font2, 14, java.awt.Color.YELLOW, java.awt.Color.RED, Utils.getDataDir() + "hello2_lora_out.jpg");
      } catch (Exception ex) {
      	ex.printStackTrace();
      }