Rendern von Text mit Schriftarten in Java

Im vorherigen Artikel haben Sie gesehen, wie Sie CFF, TrueType und Type1-Schriftarten programmgesteuert mit Java laden. Heute werden wir ein weiteres interessantes Feature unserer API zur Bearbeitung von Java-Schriftarten erörtern – das Rendern von Text mithilfe von Schriftarten. Am Ende dieses Artikels werden Sie in der Lage sein, Text mit TrueType und Type1-Schriftarten aus Ihren Java Anwendungen heraus zu rendern. So lass uns anfangen.

API zur Bearbeitung von Java-Schriftarten

Aspose.Font for Java bietet Ihnen Funktionen zum Laden und Speichern der Schriftarten sowie zum Abrufen der Metriken der gängigen Schriftarten, einschließlich CFF, TrueType, OpenType und Type1. Darüber hinaus können Sie mit der API den Text mit den bereitgestellten TrueType oder Type1-Schriftarten rendern. Sie können die API entweder mithilfe von Maven konfigurationen installieren oder die JAR Datei der API herunterladen.

<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>

Implementieren Sie die Textwiedergabemethode

Um den Text zu rendern, erfordert Aspose.Font for Java, dass Sie die Methode drawText() implementieren, die den bereitgestellten Text zeichnet. Das Folgende ist die vollständige Definition der Methode drawText().

// Vollständige Beispiele und Datendateien finden Sie unter 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
{
    //Holen Sie sich Glyphen-Identifikatoren für jedes Symbol in der Textzeile
    GlyphId[] gids = new GlyphId[text.length()];
    for (int i = 0; i < text.length(); i++)
        gids[i] = font.getEncoding().decodeToGid(text.charAt(i));
    // allgemeine Zeichnungseinstellungen festlegen
    double dpi = 300;
	
    double resolutionCorrection = dpi / 72; // 72 is font's internal dpi
    // Ausgabe-Bitmap vorbereiten
    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);
    //deklarieren Sie Koordinatenvariablen und vorherige gid
    GlyphId previousGid = null;
    double glyphXCoordinate = 0;
    double glyphYCoordinate = fontSize * resolutionCorrection;
    //Schleife, die jede Glyphe in Gids malt
    for (GlyphId gid : gids)
    {
        // wenn die Schriftart die gid enthält
        if (gid != null)
        {
            Glyph glyph = font.getGlyphAccessor().getGlyphById(gid);
            if (glyph == null)
                continue;
	
            // Pfad, der Zeichnungsanweisungen akzeptiert
            GeneralPath path = new GeneralPath();
	
            // Erstellen Sie eine IGlyphOutlinePainter-Implementierung
            GlyphOutlinePainter outlinePainter = new GlyphOutlinePainter(path);
	
            // Erstellen Sie den Renderer
            IGlyphRenderer renderer = new GlyphOutlineRenderer(outlinePainter);
	
            // allgemeine Glypheneigenschaften erhalten
            double kerning = 0;
	
            // Kerningwert erhalten
            if (previousGid != null)
            {
                kerning = (font.getMetrics().getKerningValue(previousGid, gid) /
                           glyph.getSourceResolution()) * fontSize * resolutionCorrection;
                kerning += fontWidthToImageWdith(font.getMetrics().getGlyphWidth(previousGid),
                        glyph.getSourceResolution(), fontSize, 300);
            }
	
            // Glyphenpositionierung - Erhöhen Sie die X-Koordinate der Glyphe entsprechend dem Kerning-Abstand
            glyphXCoordinate += kerning;
	
            // Glyphenplatzierungsmatrix
            TransformationMatrix glyphMatrix =
                new TransformationMatrix(
                    new double[]
                            {
                                    fontSize*resolutionCorrection,
                                    0,
                                    0,
                                // negativ, da das Bitmap-Koordinatensystem von oben beginnt
                                    - fontSize*resolutionCorrection,
                                    glyphXCoordinate,
                                    glyphYCoordinate
                            });
	
            // Aktuelle Glyphe rendern
            renderer.renderGlyph(font, gid, glyphMatrix);
            // den Weg füllen
            path.setWindingRule(GeneralPath.WIND_NON_ZERO);
            outGraphics.setPaint(textBrush);
            outGraphics.fill(path);
        }
        //setze die aktuelle gid wie zuvor, um das richtige Kerning für die nächste Glyphe zu erhalten
        previousGid = gid;
    }
    //Ergebnisse speichern
    ImageIO.write(outBitmap, "jpg", new File(outFile));
}

Das Folgende ist eine Hilfsmethode, die verwendet wird, um die Glyphenbreite für das Bitmap-Koordinatensystem zu berechnen.

// Vollständige Beispiele und Datendateien finden Sie unter 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;
}

Schritte zum Rendern von Text mit Schriftart in Java

Im Folgenden finden Sie die Schritte zum Rendern eines bestimmten Texts als Bilddatei unter Verwendung der oben erwähnten Methode darwText().

  • Laden Sie die Schriftart mithilfe der Klasse FontDefinition.
  • Greifen Sie über die Klasse wie Type1Font oder TtfFont auf die Schriftart zu.
  • Rufen Sie die Methode drawText() auf, indem Sie die Details in Form ihrer Parameter bereitstellen.

Rendern Sie Text mit TrueType-Schriftart mit Java

Das folgende Codebeispiel zeigt, wie die Methode drawText() zum Rendern von Text mit einer TrueType-Schriftart verwendet wird. Die Rendering-Ergebnisse werden als JPEG Bild generiert.

// Vollständige Beispiele und Datendateien finden Sie unter 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();
      }

Rendern Sie Text mit Type1-Schriftarten in Java

Das folgende Codebeispiel zeigt, wie Text mithilfe von Java mit einer Type1-Schriftart in ein JPEG Bild gerendert wird.

// Vollständige Beispiele und Datendateien finden Sie unter 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();
      }

Fazit

In diesem Artikel haben Sie gesehen, wie Sie den Text als JPEG Bilder rendern, indem Sie die TrueType oder Type1-Schriftart in den Java Anwendungen verwenden. Um mehr über die API zur Bearbeitung von Java-Schriftarten zu erfahren, können Sie die Dokumentation aufrufen und die Funktionen der API anhand von Quellcodebeispielen bewerten.