rendre le texte en utilisant la police en Java

Dans l’article précédent, vous avez vu comment charger les polices CFF, TrueType et Type1 par programmation à l’aide de Java. Aujourd’hui, nous allons discuter d’une autre fonctionnalité intéressante de notre API de manipulation de polices Java - le rendu du texte à l’aide de polices. À la fin de cet article, vous serez en mesure de restituer du texte à l’aide des polices TrueType et Type1 à partir de vos applications Java. Alors commençons.

API de manipulation de polices Java

Aspose.Font for Java vous offre les fonctionnalités de chargement et d’enregistrement des polices ainsi que l’obtention des métriques des types de polices populaires, notamment CFF, TrueType, OpenType et Type1. De plus, l’API vous permet de restituer le texte à l’aide des polices TrueType ou Type1 fournies. Vous pouvez soit installer l’API à l’aide des configurations Maven, soit télécharger le JAR de l’API.

<repository>
    <id>AsposeJavaAPI</id>
    <name>Aspose Java API</name>
    <url>https://repository.aspose.com/repo/</url>
</repository>
<dependency>
    <groupId>com.aspose</groupId>
    <artifactId>aspose-font</artifactId>
    <version>20.10</version>
</dependency>

Implémenter la méthode de rendu du texte

Afin de restituer le texte, Aspose.Font for Java vous oblige à implémenter la méthode drawText() qui dessinera le texte fourni. Voici la définition complète de la méthode drawText().

// Pour des exemples complets et des fichiers de données, rendez-vous sur 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
{
    //Obtenir des identifiants de glyphe pour chaque symbole dans la ligne de texte
    GlyphId[] gids = new GlyphId[text.length()];
    for (int i = 0; i < text.length(); i++)
        gids[i] = font.getEncoding().decodeToGid(text.charAt(i));
    // définir les paramètres de dessin communs
    double dpi = 300;
	
    double resolutionCorrection = dpi / 72; // 72 is font's internal dpi
    // préparer le bitmap de sortie
    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);
    //déclarer les variables de coordonnées et le gid précédent
    GlyphId previousGid = null;
    double glyphXCoordinate = 0;
    double glyphYCoordinate = fontSize * resolutionCorrection;
    //boucle qui peint chaque glyphe dans gids
    for (GlyphId gid : gids)
    {
        // si la police contient le gid
        if (gid != null)
        {
            Glyph glyph = font.getGlyphAccessor().getGlyphById(gid);
            if (glyph == null)
                continue;
	
            // chemin qui accepte les instructions de dessin
            GeneralPath path = new GeneralPath();
	
            // Créer une implémentation IGlyphOutlinePainter
            GlyphOutlinePainter outlinePainter = new GlyphOutlinePainter(path);
	
            // Créer le moteur de rendu
            IGlyphRenderer renderer = new GlyphOutlineRenderer(outlinePainter);
	
            // obtenir les propriétés communes des glyphes
            double kerning = 0;
	
            // obtenir la valeur de crénage
            if (previousGid != null)
            {
                kerning = (font.getMetrics().getKerningValue(previousGid, gid) /
                           glyph.getSourceResolution()) * fontSize * resolutionCorrection;
                kerning += fontWidthToImageWdith(font.getMetrics().getGlyphWidth(previousGid),
                        glyph.getSourceResolution(), fontSize, 300);
            }
	
            // positionnement du glyphe - augmente la coordonnée X du glyphe en fonction de la distance de crénage
            glyphXCoordinate += kerning;
	
            // Matrice de placement des glyphes
            TransformationMatrix glyphMatrix =
                new TransformationMatrix(
                    new double[]
                            {
                                    fontSize*resolutionCorrection,
                                    0,
                                    0,
                                // négatif car le système de coordonnées bitmap commence par le haut
                                    - fontSize*resolutionCorrection,
                                    glyphXCoordinate,
                                    glyphYCoordinate
                            });
	
            // rendre le glyphe actuel
            renderer.renderGlyph(font, gid, glyphMatrix);
            // remplir le chemin
            path.setWindingRule(GeneralPath.WIND_NON_ZERO);
            outGraphics.setPaint(textBrush);
            outGraphics.fill(path);
        }
        //définir le gid actuel comme précédent pour obtenir le crénage correct pour le glyphe suivant
        previousGid = gid;
    }
    //Enregistrer les résultats
    ImageIO.write(outBitmap, "jpg", new File(outFile));
}

Ce qui suit est une méthode utilitaire utilisée pour calculer la largeur de glyphe pour le système de coordonnées bitmap.

// Pour des exemples complets et des fichiers de données, rendez-vous sur 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;
}

Étapes pour rendre du texte avec une police en Java

Voici les étapes de rendu d’un texte spécifié sous forme de fichier image à l’aide de la méthode darwText() mentionnée ci-dessus.

  • Chargez la police à l’aide de la classe FontDefinition.
  • Accédez à la police à l’aide de la classe telle que Type1Font ou TtfFont.
  • Appelez la méthode drawText() en fournissant les détails sous la forme de ses paramètres.

Rendu du texte avec la police TrueType à l’aide de Java

L’exemple de code suivant montre comment utiliser la méthode drawText() pour restituer du texte à l’aide d’une police TrueType. Les résultats du rendu seront générés sous forme d’image JPEG.

// Pour des exemples complets et des fichiers de données, rendez-vous sur 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();
      }

Rendu du texte à l’aide de polices Type1 en Java

L’exemple de code suivant montre comment restituer du texte dans une image JPEG avec une police Type1 à l’aide de Java.

// Pour des exemples complets et des fichiers de données, rendez-vous sur https://github.com/aspose-font/Aspose.Font-for-Java
String fileName = Utils.getDataDir() + "courier.pfb"; //Font file name with full path

FontDefinition fd = new FontDefinition(FontType.Type1, new FontFileDefinition("pfb", new FileSystemStreamSource(fileName)));
      Type1Font font = (Type1Font) Font.open(fd);
      
      try {
       drawText("Hello world", font, 14, java.awt.Color.WHITE, java.awt.Color.BLACK, Utils.getDataDir() + "hello1_type1_out.jpg");
       drawText("Hello world", font, 14, java.awt.Color.YELLOW, java.awt.Color.RED, Utils.getDataDir() + "hello2_type1_out.jpg");
      } catch (Exception ex) {
      	ex.printStackTrace();
      }

Conclusion

Dans cet article, vous avez vu comment restituer le texte sous forme d’images JPEG à l’aide de la police TrueType ou Type1 à partir des applications Java. Pour en savoir plus sur l’API de manipulation de polices Java, vous pouvez consulter la documentation et évaluer les fonctionnalités de l’API à l’aide des exemples de code source.