Java: Rendera text med TrueType- och Type1-teckensnitt med Java Font API

rendera text med hjälp av typsnitt i Java

I den föregående artikeln har du sett hur du läser in CFF, TrueType och Type1 teckensnitt programmatiskt med Java. Idag kommer vi att diskutera en annan intressant funktion i vårt Java-fontmanipulerings-API - rendering av text med hjälp av typsnitt. I slutet av den här artikeln kommer du att kunna rendera text med TrueType- och Type1-teckensnitt från dina Java-program. Så låt oss börja.

Om Java Font Manipulation API
Implementera textåtergivningsmetod
Återge text med TrueType-teckensnitt i Java
Rendera text med Type1-teckensnitt i Java

Java Font Manipulation API

Aspose.Font for Java ger dig funktionerna för att ladda och spara teckensnitten samt få mätvärden för de populära teckensnittstyperna inklusive CFF, TrueType, OpenType och Type1. Dessutom låter API:et dig återge texten med de medföljande TrueType- eller Type1-teckensnitten. Du kan antingen installera API:t med Maven-konfigurationer eller ladda ner API:s JAR.

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

Implementera textåtergivningsmetod

För att rendera texten kräver Aspose.Font för Java att du implementerar metoden drawText() som kommer att rita den tillhandahållna texten. Följande är den fullständiga definitionen av metoden drawText() .

// För fullständiga exempel och datafiler, gå till 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
{
    //Få glyfidentifierare för varje symbol i textraden
    GlyphId[] gids = new GlyphId[text.length()];
   for (int i = 0; i < text.length(); i++)
        gids[i] = font.getEncoding().decodeToGid(text.charAt(i));
    // ange vanliga ritinställningar
    double dpi = 300;
	
    double resolutionCorrection = dpi / 72; // 72 is font's internal dpi
    // förbered utdatabitmapp
    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);
    //deklarera koordinatvariabler och föregående gid
    GlyphId previousGid = null;
    double glyphXCoordinate = 0;
    double glyphYCoordinate = fontSize * resolutionCorrection;
    //loop som målar varje glyf i guide
   for (GlyphId gid : gids)
    {
        // om typsnittet innehåller gid
        if (gid != null)
        {
            Glyph glyph = font.getGlyphAccessor().getGlyphById(gid);
            if (glyph == null)
                continue;
	
            // sökväg som accepterar ritningsinstruktioner
            GeneralPath path = new GeneralPath();
	
            // Skapa IGlyphOutlinePainter-implementering
            GlyphOutlinePainter outlinePainter = new GlyphOutlinePainter(path);
	
            // Skapa renderaren
            IGlyphRenderer renderer = new GlyphOutlineRenderer(outlinePainter);
	
            // få vanliga glyfegenskaper
            double kerning = 0;
	
            // få kerning värde
            if (previousGid != null)
            {
                kerning = (font.getMetrics().getKerningValue(previousGid, gid) /
                           glyph.getSourceResolution()) * fontSize * resolutionCorrection;
                kerning += fontWidthToImageWdith(font.getMetrics().getGlyphWidth(previousGid),
                        glyph.getSourceResolution(), fontSize, 300);
            }
	
            // glyph positionering - öka glyph X-koordinaten enligt kerning avstånd
            glyphXCoordinate += kerning;
	
            // Glyfplaceringsmatris
            TransformationMatrix glyphMatrix =
                new TransformationMatrix(
                    new double[]
                            {
                                    fontSize*resolutionCorrection,
                                    0,
                                    0,
                                // negativ på grund av bitmappskoordinatsystem börjar från toppen
                                    - fontSize*resolutionCorrection,
                                    glyphXCoordinate,
                                    glyphYCoordinate
                            });
	
            // rendera aktuell glyf
            renderer.renderGlyph(font, gid, glyphMatrix);
            // fyll vägen
            path.setWindingRule(GeneralPath.WIND_NON_ZERO);
            outGraphics.setPaint(textBrush);
            outGraphics.fill(path);
        }
        //ställ in nuvarande gid som tidigare för att få korrekt kerning för nästa glyf
        previousGid = gid;
    }
    //Spara resultat
    ImageIO.write(outBitmap, "jpg", new File(outFile));
}

Följande är en verktygsmetod som används för att beräkna glyfbredden för bitmappskoordinatsystem.

// För fullständiga exempel och datafiler, gå till 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;
}

Steg för att rendera text med teckensnitt i Java

Följande är stegen för hur du renderar en specificerad text som en bildfil med den ovan nämnda darwText()-metoden.

Ladda teckensnittet med klassen FontDefinition.
Få åtkomst till teckensnittet med klassen som Type1Font eller TtfFont.
Anropa metoden drawText() genom att tillhandahålla detaljerna i form av dess parametrar.

Återge text med TrueType Font med Java

Följande kodexempel visar hur man använder metoden drawText() för att rendera text med ett TrueType-teckensnitt. Återgivningsresultaten kommer att genereras som en JPEG-bild.

// För fullständiga exempel och datafiler, gå till 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();
      }

Återge text med Type1-teckensnitt i Java

Följande kodexempel visar hur man renderar text till en JPEG-bild med ett Typ1-teckensnitt med Java.

// För fullständiga exempel och datafiler, gå till 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();
      }

Slutsats

I den här artikeln har du sett hur du renderar texten som JPEG-bilder med TrueType- eller Type1-teckensnittet från Java-applikationerna. För att lära dig mer om Java font manipulation API kan du besöka dokumentationen och utvärdera API:ets funktioner med hjälp av källkodsexempel.

Java Font Manipulation API#

Implementera textåtergivningsmetod#

Steg för att rendera text med teckensnitt i Java#

Återge text med TrueType Font med Java#

Återge text med Type1-teckensnitt i Java#

Slutsats#