Textwiedergabe mit TrueType-Schriftart | Java

Text rendern

Zum Rendern von Text erfordert das Rendering-Subsystem die Implementierung der Schnittstelle Aspose.Font.Rendering.IGlyphOutlinePainter zum Zeichnen von Glyphen. Dies kann mit den folgenden Schritten erreicht werden.

1. Erstellen Sie die Methode „DrawText()“, die den angegebenen Text in das System.Drawing.Bitmap-Objekt zeichnet und die resultierende Bitmap auf der Disc speichert. Dies umfasst die folgenden Schritte:

• Iterieren Sie alle Symbole in der Textzeichenfolge.
• Glyphen-ID für jedes verarbeitete Symbol abrufen – GID.
• Erstellen Sie ein Objekt vom Typ GlyphOutlinePainter, das vom Rendering-Subsystem zum Zeichnen der aktuellen Glyphe benötigt wird.
• Erstellen Sie ein Objekt vom Typ Aspose.Font.Renderers.GlyphOutlineRenderer und übergeben Sie das gerade erstellte Objekt vom Typ GlyphOutlinePainter an den Konstruktor für GlyphOutlineRenderer. Dieses Objekt GlyphOutlineRenderer soll die angegebene Glyphe rendern.
• Rendern Sie das aktuell verarbeitete Glyph mit der Methode GlyphOutlineRenderer.RenderGlyph(). Das Aspose.Fonts.Matrix-Objekt wird zum Angeben von Glyphenkoordinaten verwendet. Die zu rendernde Glyphe wird durch den GID-Parameter angegeben.

„Hilfsschritte für diese Strategie“.

• Die Glyphenkoordinate für die Y-Achse ist für dieses Codefragment konstant.
• Die Glyphenkoordinate für die X-Achse wird für jede verarbeitete Glyphe berechnet.
• Sowohl die X- als auch die Y-Koordinaten werden an das Objekt Aspose.Fonts.Matrix übergeben, das von GlyphOutlineRenderer zum Zeichnen von Glyphen verwendet wird.
• Der Abstand zwischen gerade verarbeiteten und vorherigen Glyphen wird bei jedem Iterationsschritt berechnet. Dieser Abstand wirkt sich auf jede Glyphen-X-Koordinate aus.
• Ein Objekt vom Typ GlyphOutlinePainter zeichnet Glyphen mithilfe von GlyphOutlinePainter nicht direkt in Bitmap, sondern in das Objekt GraphicsPath, das an den Konstruktor für GlyphOutlinePainter übergeben wurde. Daher verwenden wir ein Objekt vom Typ System.Drawing.Graphics, um GraphicsPath in Bitmap zu zeichnen.
• Methode FontWidthToImageWith(), die die Glyphenbreite für das Bitmap-Koordinatensystem berechnet.

Die Implementierung der DrawText-Methode ist wie unten dargestellt.

// For complete examples and data files, please go to 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
{
    //Get glyph identifiers for every symbol in text line
    GlyphId[] gids = new GlyphId[text.length()];
    for (int i = 0; i < text.length(); i++)
        gids[i] = font.getEncoding().decodeToGid(text.charAt(i));
    // set common drawing settings
    double dpi = 300;
	
    double resolutionCorrection = dpi / 72; // 72 is font's internal dpi
    // prepare output bitmap
    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);
    //declare coordinate variables and previous gid
    GlyphId previousGid = null;
    double glyphXCoordinate = 0;
    double glyphYCoordinate = fontSize * resolutionCorrection;
    //loop which paints every glyph in gids
    for (GlyphId gid : gids)
    {
        // if the font contains the gid
        if (gid != null)
        {
            Glyph glyph = font.getGlyphAccessor().getGlyphById(gid);
            if (glyph == null)
                continue;
	
            // path that accepts drawing instructions
            GeneralPath path = new GeneralPath();
	
            // Create IGlyphOutlinePainter implementation
            GlyphOutlinePainter outlinePainter = new GlyphOutlinePainter(path);
	
            // Create the renderer
            IGlyphRenderer renderer = new GlyphOutlineRenderer(outlinePainter);
	
            // get common glyph properties
            double kerning = 0;
	
            // get kerning value
            if (previousGid != null)
            {
                kerning = (font.getMetrics().getKerningValue(previousGid, gid) /
                           glyph.getSourceResolution()) * fontSize * resolutionCorrection;
                kerning += fontWidthToImageWdith(font.getMetrics().getGlyphWidth(previousGid),
                        glyph.getSourceResolution(), fontSize, 300);
            }
	
            // glyph positioning - increase glyph X coordinate according to kerning distance
            glyphXCoordinate += kerning;
	
            // Glyph placement matrix
            TransformationMatrix glyphMatrix =
                new TransformationMatrix(
                    new double[]
                            {
                                    fontSize*resolutionCorrection,
                                    0,
                                    0,
                                // negative because of bitmap coordinate system begins from the top
                                    - fontSize*resolutionCorrection,
                                    glyphXCoordinate,
                                    glyphYCoordinate
                            });
	
            // render current glyph
            renderer.renderGlyph(font, gid, glyphMatrix);
            // fill the path
            path.setWindingRule(GeneralPath.WIND_NON_ZERO);
            outGraphics.setPaint(textBrush);
            outGraphics.fill(path);
        }
        //set current gid as previous to get correct kerning for next glyph
        previousGid = gid;
    }
    //Save results
    ImageIO.write(outBitmap, "jpg", new File(outFile));
}

1. Erstellen Sie eine Dienstprogrammmethode, um die Schriftbreite in die Bildbreite umzurechnen, wie im folgenden Codebeispiel gezeigt

// For complete examples and data files, please go to 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;
}

Aufrufen der Funktion „Text rendern“.

Um die oben genannten Implementierungen zu verwenden, kann der folgende Beispielcode über die Main-Methode einer konsolenbasierten Anwendung ausgeführt werden.

// For complete examples and data files, please go to 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();
      }