Rendu de texte à l'aide de la police TrueType | Java

Rendu du texte

Afin de restituer le texte, le sous-système de rendu nécessite l’implémentation de l’interface Aspose.Font.Rendering.IGlyphOutlinePainter pour dessiner le glyphe. Ceci peut être réalisé en suivant les étapes suivantes.

1. Créez la méthode DrawText() qui dessine le texte spécifié dans l’objet System.Drawing.Bitmap et enregistre le bitmap résultant sur le disque. Cela comprendra les étapes suivantes :

• Itérer tous les symboles dans la chaîne de texte.
• Obtenez l’identifiant de glyphe pour chaque symbole traité - gid.
• Créez un objet de type GlyphOutlinePainter qui est requis par le sous-système de rendu pour dessiner le glyphe actuel.
• Créez un objet de type Aspose.Font.Renderers.GlyphOutlineRenderer et transmettez l’objet de type GlyphOutlinePainter que vous venez de créer dans le constructeur de GlyphOutlineRenderer. Cet objet GlyphOutlineRenderer était destiné à restituer le glyphe spécifié.
• Rendre le glyphe traité actuel à l’aide de la méthode GlyphOutlineRenderer.RenderGlyph(). L’objet Aspose.Fonts.Matrix est utilisé pour spécifier les coordonnées du glyphe. Le glyphe à restituer est spécifié par le paramètre gid.

Étapes auxiliaires pour cette stratégie

• La coordonnée du glyphe pour l’axe ‘Y’ est constante pour cet extrait de code.
• Les coordonnées du glyphe pour l’axe ‘X’ sont calculées pour chaque glyphe traité.
• Les coordonnées ‘X’ et ‘Y’ sont transmises à l’objet Aspose.Fonts.Matrix qui est utilisé par GlyphOutlineRenderer pour dessiner un glyphe.
• La distance entre les glyphes qui viennent d’être traités et les glyphes précédents est calculée à chaque étape d’itération. Cette distance affecte chaque coordonnée ‘X’ de glyphe.
• L’objet de type GlyphOutlinePainter dessine le glyphe à l’aide de GlyphOutlinePainter non pas directement dans Bitmap, mais dans l’objet GraphicsPath, qui a été passé au constructeur pour GlyphOutlinePainter, nous utilisons donc un objet de type System.Drawing.Graphics pour dessiner GraphicsPath dans Bitmap.
• Méthode FontWidthToImageWith() qui calcule la largeur du glyphe pour le système de coordonnées bitmap.

L’implémentation de la méthode DrawText est comme indiqué ci-dessous.

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

    private GlyphOutlinePainter(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 GlyphOutlinePainter(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. créer une méthode utilitaire pour calculer la largeur de la police par rapport à la largeur de l’image, comme indiqué dans l’exemple de code ci-dessous

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

Appel de la fonctionnalité Rendu du texte

Pour utiliser les implémentations ci-dessus, l’exemple de code suivant peut être exécuté à partir de la méthode Main d’une application basée sur console.

String firstFontPath = Paths.get(getDataDir(), "..", "TTF", "montserrat-bold.ttf")
        .normalize().toString();
String secondFontPath = Paths.get(getDataDir(), "..", "TTF", "LatoWeb-Regular.ttf")
        .normalize().toString();
TtfFont firstFont = (TtfFont) Font.open(new FontDefinition(FontType.TTF,
        new FontFileDefinition("ttf", new FileSystemStreamSource(firstFontPath))));
TtfFont secondFont = (TtfFont) Font.open(new FontDefinition(FontType.TTF,
        new FontFileDefinition("ttf", new FileSystemStreamSource(secondFontPath))));

String firstOutput = Paths.get(getOutputDir(), "hello1_montserrat_out.png").toString();
String secondOutput = Paths.get(getOutputDir(), "hello2_lato_out.png").toString();
drawText("Hello world", firstFont, 14, Color.WHITE, Color.BLACK, firstOutput);
drawText("Hello world", secondFont, 14, Color.YELLOW, Color.RED, secondOutput);