Java: renderizar texto com fontes TrueType e Type1 usando a API de fontes Java

No artigo anterior, você viu como carregar as fontes CFF, TrueType e Type1 programaticamente usando Java. Hoje, discutiremos outro recurso interessante da nossa API de manipulação de fontes Java - renderização de texto usando fontes. No final deste artigo, você poderá renderizar texto usando fontes TrueType e Type1 de dentro de seus aplicativos Java. Então vamos começar.

Sobre a API de manipulação de fontes Java
Implementar método de renderização de texto
Renderizar texto usando fontes TrueType em Java
Renderizar texto usando fontes Type1 em Java

API de manipulação de fontes Java

Aspose.Font for Java fornece os recursos de carregar e salvar as fontes, bem como obter as métricas dos tipos de fontes populares, incluindo CFF, TrueType, OpenType e Type1. Além disso, a API permite renderizar o texto usando as fontes TrueType ou Type1 fornecidas. Você pode instalar a API usando as configurações do Maven ou download o JAR da 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>

Implementar método de renderização de texto

Para renderizar o texto, Aspose.Font for Java requer que você implemente o método drawText() que desenhará o texto fornecido. A seguir está a definição completa do método drawText().

// Para exemplos completos e arquivos de dados, acesse 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
{
    //Obtenha identificadores de glifo para cada símbolo na linha de texto
    GlyphId[] gids = new GlyphId[text.length()];
    for (int i = 0; i < text.length(); i++)
        gids[i] = font.getEncoding().decodeToGid(text.charAt(i));
    // definir configurações de desenho comuns
    double dpi = 300;
	
    double resolutionCorrection = dpi / 72; // 72 is font's internal dpi
    // preparar bitmap de saída
    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);
    //declarar variáveis de coordenadas e gid anterior
    GlyphId previousGid = null;
    double glyphXCoordinate = 0;
    double glyphYCoordinate = fontSize * resolutionCorrection;
    //loop que pinta todos os glifos em gids
    for (GlyphId gid : gids)
    {
        // se a fonte contém o gid
        if (gid != null)
        {
            Glyph glyph = font.getGlyphAccessor().getGlyphById(gid);
            if (glyph == null)
                continue;
	
            // caminho que aceita instruções de desenho
            GeneralPath path = new GeneralPath();
	
            // Criar implementação de IGlyphOutlinePainter
            GlyphOutlinePainter outlinePainter = new GlyphOutlinePainter(path);
	
            // Crie o renderizador
            IGlyphRenderer renderer = new GlyphOutlineRenderer(outlinePainter);
	
            // obter propriedades comuns de glifo
            double kerning = 0;
	
            // obter valor de kerning
            if (previousGid != null)
            {
                kerning = (font.getMetrics().getKerningValue(previousGid, gid) /
                           glyph.getSourceResolution()) * fontSize * resolutionCorrection;
                kerning += fontWidthToImageWdith(font.getMetrics().getGlyphWidth(previousGid),
                        glyph.getSourceResolution(), fontSize, 300);
            }
	
            // posicionamento do glifo - aumenta a coordenada do glifo X de acordo com a distância de kerning
            glyphXCoordinate += kerning;
	
            // Matriz de posicionamento de glifo
            TransformationMatrix glyphMatrix =
                new TransformationMatrix(
                    new double[]
                            {
                                    fontSize*resolutionCorrection,
                                    0,
                                    0,
                                // negativo por causa do sistema de coordenadas bitmap começa a partir do topo
                                    - fontSize*resolutionCorrection,
                                    glyphXCoordinate,
                                    glyphYCoordinate
                            });
	
            // renderizar glifo atual
            renderer.renderGlyph(font, gid, glyphMatrix);
            // preencha o caminho
            path.setWindingRule(GeneralPath.WIND_NON_ZERO);
            outGraphics.setPaint(textBrush);
            outGraphics.fill(path);
        }
        //defina o gid atual como anterior para obter o kerning correto para o próximo glifo
        previousGid = gid;
    }
    //Salvar resultados
    ImageIO.write(outBitmap, "jpg", new File(outFile));
}

A seguir está um método utilitário que é usado para calcular a largura do glifo para o sistema de coordenadas de bitmap.

// Para exemplos completos e arquivos de dados, acesse 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;
}

Etapas para renderizar texto com fonte em Java

A seguir estão as etapas de como renderizar um texto especificado como um arquivo de imagem usando o método darwText() mencionado acima.

Carregue a fonte usando a classe FontDefinition.
Acesse a fonte usando a classe como Type1Font ou TtfFont.
Chame o método drawText() fornecendo os detalhes na forma de seus parâmetros.

Renderizar texto com fonte TrueType usando Java

O exemplo de código a seguir mostra como usar o método drawText() para renderizar texto usando uma fonte TrueType. Os resultados da renderização serão gerados como uma imagem JPEG.

// Para exemplos completos e arquivos de dados, acesse 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();
      }

Renderizar texto usando fontes Type1 em Java

O exemplo de código a seguir mostra como renderizar texto em uma imagem JPEG com uma fonte Type1 usando Java.

// Para exemplos completos e arquivos de dados, acesse 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();
      }

Conclusão

Neste artigo, você viu como renderizar o texto como imagens JPEG usando a fonte TrueType ou Type1 de dentro dos aplicativos Java. Para saber mais sobre a API de manipulação de fontes Java, você pode visitar a documentação e avaliar os recursos da API usando amostras de código-fonte.

API de manipulação de fontes Java#

Implementar método de renderização de texto#

Etapas para renderizar texto com fonte em Java#

Renderizar texto com fonte TrueType usando Java#

Renderizar texto usando fontes Type1 em Java#

Conclusão#