Text Rendering using Type1 Font | .NET

Rendering Text

To render text with the glyph outline renderer, implement the Aspose.Font.Rendering.IGlyphOutlinePainter interface and use it to build paths for individual glyphs.

1. Create a Type1GlyphOutlinePainter class that accepts a System.Drawing.Drawing2D.GraphicsPath. Its methods translate the font outline commands into lines and Bézier curves in that path.

// Implement a painter that builds a graphics path from a glyph outline

internal sealed class Type1GlyphOutlinePainter : IGlyphOutlinePainter
{
    private readonly GraphicsPath path;
    private PointF currentPoint;

    public Type1GlyphOutlinePainter(GraphicsPath path)
    {
        this.path = path;
    }

    public void MoveTo(MoveTo moveTo)
    {
        path.CloseFigure();
        currentPoint = new PointF((float)moveTo.X, (float)moveTo.Y);
    }

    public void LineTo(LineTo lineTo)
    {
        PointF nextPoint = new PointF((float)lineTo.X, (float)lineTo.Y);
        path.AddLine(currentPoint, nextPoint);
        currentPoint = nextPoint;
    }

    public void CurveTo(CurveTo curveTo)
    {
        PointF nextPoint = new PointF((float)curveTo.X3, (float)curveTo.Y3);
        path.AddBezier(
            currentPoint,
            new PointF((float)curveTo.X1, (float)curveTo.Y1),
            new PointF((float)curveTo.X2, (float)curveTo.Y2),
            nextPoint);
        currentPoint = nextPoint;
    }

    public void ClosePath()
    {
        path.CloseFigure();
    }
}

2. Create a DrawText() method that draws text into a System.Drawing.Bitmap and saves it as a PNG file. The method performs the following operations:

• Decode every character in the text into a glyph ID.
• Create a 960 × 720 bitmap at 300 DPI, fill its background, and enable high-quality smoothing.
• For each glyph, add the previous glyph’s advance width and the pair kerning value to its horizontal position.
• Create a GraphicsPath, a Type1GlyphOutlinePainter, and a GlyphOutlineRenderer for the current glyph.
• Use a TransformationMatrix to scale and position the glyph, then fill the resulting path with the requested text brush.
• Save the bitmap explicitly as PNG. The bitmap, graphics object, and glyph paths are disposed after use.

The glyph baseline remains constant in this example. The horizontal coordinate is accumulated from the previous glyph’s advance and kerning. FontWidthToImageWidth() converts font units to bitmap pixels using the source resolution, font size, and DPI.

The implementation of DrawText() is shown below.

// Render text into a bitmap with a custom glyph outline painter

private static void DrawText(string text, IFont font, double fontSize,
    Brush backgroundBrush, Brush textBrush, string outputFile)
{
    GlyphId[] glyphIds = text
        .Select(character => font.Encoding.DecodeToGid(character))
        .ToArray();
    const double dpi = 300;
    double resolutionCorrection = dpi / 72;

    using var outputBitmap = new Bitmap(960, 720);
    outputBitmap.SetResolution((float)dpi, (float)dpi);
    using Graphics outputGraphics = Graphics.FromImage(outputBitmap);
    outputGraphics.FillRectangle(backgroundBrush, 0, 0, outputBitmap.Width, outputBitmap.Height);
    outputGraphics.SmoothingMode = SmoothingMode.HighQuality;

    GlyphId? previousGlyphId = null;
    double glyphXCoordinate = 0;
    double glyphYCoordinate = fontSize * resolutionCorrection;

    foreach (GlyphId glyphId in glyphIds)
    {
        Glyph glyph = font.GlyphAccessor.GetGlyphById(glyphId);
        if (glyph == null)
            continue;

        if (previousGlyphId != null)
        {
            double kerning = font.Metrics.GetKerningValue(previousGlyphId, glyphId)
                / (double)glyph.SourceResolution * fontSize * resolutionCorrection;
            double advance = FontWidthToImageWidth(
                font.Metrics.GetGlyphWidth(previousGlyphId),
                glyph.SourceResolution,
                fontSize,
                dpi);
            glyphXCoordinate += kerning + advance;
        }

        using var path = new GraphicsPath();
        var outlinePainter = new Type1GlyphOutlinePainter(path);
        IGlyphRenderer renderer = new GlyphOutlineRenderer(outlinePainter);
        var glyphMatrix = new TransformationMatrix(new double[]
        {
            fontSize * resolutionCorrection,
            0,
            0,
            -fontSize * resolutionCorrection,
            glyphXCoordinate,
            glyphYCoordinate
        });

        renderer.RenderGlyph(font, glyphId, glyphMatrix);
        path.FillMode = FillMode.Winding;
        outputGraphics.FillPath(textBrush, path);
        previousGlyphId = glyphId;
    }

    outputBitmap.Save(outputFile, ImageFormat.Png);
}

3. Add the utility method that converts a width in font units to image pixels.

// Convert a width in font units to pixels

private static double FontWidthToImageWidth(double width, int fontSourceResolution,
    double fontSize, double dpi = 300)
{
    double resolutionCorrection = dpi / 72;
    return width / fontSourceResolution * fontSize * resolutionCorrection;
}

Calling the Rendering Text functionality

The following example loads Type1/courier.pfb from DataDir, renders the same text with two color schemes, and writes both PNG files to OutputDir.

// Load a Type1 font and render text in two color schemes

string fileName = Path.Combine(DataDir, "Type1", "courier.pfb");
FontDefinition fontDefinition = new FontDefinition(
    FontType.Type1,
    new FontFileDefinition("pfb", new FileSystemStreamSource(fileName)));

Type1Font? font = Aspose.Font.Font.Open(fontDefinition) as Type1Font;
if (font == null)
    throw new InvalidOperationException("Unable to load the Type1 font.");

string firstOutput = Path.Combine(OutputDir, "hello1_type1_out.png");
string secondOutput = Path.Combine(OutputDir, "hello2_type1_out.png");
DrawText("Hello world", font, 14, Brushes.White, Brushes.Black, firstOutput);
DrawText("Hello world", font, 14, Brushes.Yellow, Brushes.Red, secondOutput);