Text Rendering using Type1 Font | Java

Rendering Text

To render text, implement com.aspose.font.IGlyphOutlinePainter to collect glyph outlines in a Java 2D GeneralPath. Combine the painter and the methods below in the same class. The examples use classes from com.aspose.font, java.awt, java.awt.geom, java.awt.image, javax.imageio, java.io and java.nio.file.

1. Create a drawText() method that draws text into a BufferedImage and saves it as a PNG file. This includes the following steps:

• Iterate all symbols in text string.
• Get glyph identifier for every processed symbol - gid.
• Create a Type1GlyphOutlinePainter to build the outline of the current glyph.
• Create a com.aspose.font.GlyphOutlineRenderer and pass the painter to its constructor.
• Render the glyph with renderGlyph(), passing its ID and a com.aspose.font.TransformationMatrix that specifies scaling and placement.

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 to the TransformationMatrix used by GlyphOutlineRenderer.
• Distance between just processed and previous glyphs is calculated on every iteration step. This distance affects every glyph ‘X’ coordinate.
• The painter builds a GeneralPath; a Graphics2D object then fills that path in the image.
• The fontWidthToImageWidth() method converts glyph advance widths to image coordinates.

The following snippets implement the outline painter and drawText() method. The DPI value controls glyph scaling; it does not set PNG resolution metadata.

private static final class Type1GlyphOutlinePainter implements IGlyphOutlinePainter {
    private final GeneralPath path;

    private Type1GlyphOutlinePainter(GeneralPath path) {
        this.path = path;
    }

    @Override
    public void moveTo(MoveTo moveTo) {
        path.moveTo(moveTo.getX(), moveTo.getY());
    }

    @Override
    public void lineTo(LineTo lineTo) {
        path.lineTo(lineTo.getX(), lineTo.getY());
    }

    @Override
    public void curveTo(CurveTo curveTo) {
        path.curveTo(curveTo.getX1(), curveTo.getY1(), curveTo.getX2(), curveTo.getY2(),
                curveTo.getX3(), curveTo.getY3());
    }

    @Override
    public void closePath() {
        path.closePath();
    }
}

private static void drawText(String text, IFont font, double fontSize,
        Paint backgroundBrush, Paint textBrush, String outputFile) throws IOException {
    GlyphId[] glyphIds = new GlyphId[text.length()];
    for (int i = 0; i < text.length(); i++) {
        glyphIds[i] = font.getEncoding().decodeToGid(text.charAt(i));
    }
    double dpi = 300;
    double resolutionCorrection = dpi / 72;
    BufferedImage outputBitmap = new BufferedImage(960, 720, BufferedImage.TYPE_INT_RGB);
    Graphics2D graphics = outputBitmap.createGraphics();
    try {
        graphics.setPaint(backgroundBrush);
        graphics.fillRect(0, 0, outputBitmap.getWidth(), outputBitmap.getHeight());
        graphics.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        GlyphId previousGlyphId = null;
        double glyphXCoordinate = 0;
        double glyphYCoordinate = fontSize * resolutionCorrection;
        for (GlyphId glyphId : glyphIds) {
            if (glyphId == null) {
                continue;
            }
            Glyph glyph = font.getGlyphAccessor().getGlyphById(glyphId);
            if (glyph == null) {
                continue;
            }
            if (previousGlyphId != null) {
                double kerning = font.getMetrics().getKerningValue(previousGlyphId, glyphId)
                        / glyph.getSourceResolution() * fontSize * resolutionCorrection;
                double advance = fontWidthToImageWidth(font.getMetrics().getGlyphWidth(previousGlyphId),
                        glyph.getSourceResolution(), fontSize, dpi);
                glyphXCoordinate += kerning + advance;
            }
            GeneralPath path = new GeneralPath();
            IGlyphRenderer renderer = new GlyphOutlineRenderer(new Type1GlyphOutlinePainter(path));
            TransformationMatrix matrix = new TransformationMatrix(new double[] {
                    fontSize * resolutionCorrection, 0, 0, -fontSize * resolutionCorrection,
                    glyphXCoordinate, glyphYCoordinate
            });
            renderer.renderGlyph(font, glyphId, matrix);
            path.setWindingRule(GeneralPath.WIND_NON_ZERO);
            graphics.setPaint(textBrush);
            graphics.fill(path);
            previousGlyphId = glyphId;
        }
    } finally {
        graphics.dispose();
    }
    if (!ImageIO.write(outputBitmap, "png", new File(outputFile))) {
        throw new IOException("No PNG writer is available.");
    }
}

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

private static double fontWidthToImageWidth(double width, int fontSourceResolution,
        double fontSize, double dpi) {
    return width / fontSourceResolution * fontSize * (dpi / 72);
}

Calling the Rendering Text functionality

Use the following code in your application and handle or declare IOException. It loads courier.pfb and creates two PNG images. Adapt getDataDir(), getOutputDir() and the relative input path to your application; the output directory must exist and be writable.

String fileName = Paths.get(getDataDir(), "..", "Type1", "courier.pfb").normalize().toString();
FontDefinition fd = new FontDefinition(FontType.Type1,
        new FontFileDefinition("pfb", new FileSystemStreamSource(fileName)));
Type1Font font = (Type1Font) Font.open(fd);

String firstOutput = Paths.get(getOutputDir(), "hello1_type1_out.png").toString();
String secondOutput = Paths.get(getOutputDir(), "hello2_type1_out.png").toString();
drawText("Hello world", font, 14, Color.WHITE, Color.BLACK, firstOutput);
drawText("Hello world", font, 14, Color.YELLOW, Color.RED, secondOutput);