Rendering di testo utilizzando TrueType Font | Java

Rendering Testo

Al fine di rendere il testo, il sottosistema di rendering richiede l’implementazione di Aspose.Font.Rendering.IGlyphOutlinePainter Interfaccia per disegnare glifo. Questo può essere ottenuto utilizzando i seguenti passaggi.

1. Crea metodo DrawText() che disegna il testo specificato in System.Drawing.Bitmap e salva la bitmap risultante sul disco. Ciò includerà i seguenti passaggi:

• Iterare tutti i simboli nella stringa di testo.
• Ottieni l’identificatore di glifi per ogni simbolo elaborato - GID.
• Crea oggetto di tipo GlyphOutlinePainter che è richiesto rendendo il sottosistema per disegnare il glifo di corrente.
• Crea oggetto di tipo Aspose.Font.Renderers.GlyphOutlineRenderer e passa l’oggetto appena creato di tipo GlyphOutlinePainter in costruttore per GlyphOutlineRenderer. Questo oggetto GlyphOutlineRenderer intendeva rendere il glifo specificato.
• Render la corrente elaborata Glyph utilizzando il metodo GlyphOutlineRenderer.RenderGlyph(). Aspose.Fonts.Matrix L’oggetto viene utilizzato per specificare le coordinate glifi. Il glifo da rendering è specificato dal parametro GID.

Passaggi ausiliari per questa strategia

• La coordinata glifo per l’asse ‘y’ è costante per questo frammento di codice.
• La coordinata glifo per l’asse ‘x’ viene calcolata per ogni glifo elaborato.
• Entrambe le coordinate ‘X’ e ‘Y’ vengono passate in oggetto Aspose.Fonts.Matrix che viene utilizzata da GlyphOutlineRenderer per disegnare il loro glifo.
• La distanza tra glifi appena elaborati e precedenti viene calcolata in ogni fase di iterazione. Questa distanza influisce su ogni coordinata di glifi ‘x’.
• L’oggetto di tipo GlyphOutlinePainter disegna glifo con l’aiuto di GlyphOutlinePainter non direttamente in Bitmap, ma in Object GraphicsPath, che è stato passato al costruttore per GlyphOutlinePainter, quindi utilizziamo oggetto di tipo System.Drawing.Graphics per attirare graphicspath in BitMap.
• Metodo FontWidthToImageWith() che calcola la larghezza del glifo per il sistema di coordinate BitMap.

L’implementazione del metodo DrawText è come mostrato di seguito.

private static final class GlyphOutlinePainter implements IGlyphOutlinePainter {
    private final GeneralPath path;

    private GlyphOutlinePainter(GeneralPath path) {
        this.path = path;
    }

    @Override
    public void moveTo(MoveTo moveTo) {
        path.moveTo(moveTo.getX(), moveTo.getY());
    }

    @Override
    public void lineTo(LineTo lineTo) {
        path.lineTo(lineTo.getX(), lineTo.getY());
    }

    @Override
    public void curveTo(CurveTo curveTo) {
        path.curveTo(curveTo.getX1(), curveTo.getY1(), curveTo.getX2(), curveTo.getY2(),
                curveTo.getX3(), curveTo.getY3());
    }

    @Override
    public void closePath() {
        path.closePath();
    }
}

private static void drawText(String text, IFont font, double fontSize,
        Paint backgroundBrush, Paint textBrush, String outputFile) throws IOException {
    GlyphId[] glyphIds = new GlyphId[text.length()];
    for (int i = 0; i < text.length(); i++) {
        glyphIds[i] = font.getEncoding().decodeToGid(text.charAt(i));
    }
    double dpi = 300;
    double resolutionCorrection = dpi / 72;
    BufferedImage outputBitmap = new BufferedImage(960, 720, BufferedImage.TYPE_INT_RGB);
    Graphics2D graphics = outputBitmap.createGraphics();
    try {
        graphics.setPaint(backgroundBrush);
        graphics.fillRect(0, 0, outputBitmap.getWidth(), outputBitmap.getHeight());
        graphics.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        GlyphId previousGlyphId = null;
        double glyphXCoordinate = 0;
        double glyphYCoordinate = fontSize * resolutionCorrection;
        for (GlyphId glyphId : glyphIds) {
            if (glyphId == null) {
                continue;
            }
            Glyph glyph = font.getGlyphAccessor().getGlyphById(glyphId);
            if (glyph == null) {
                continue;
            }
            if (previousGlyphId != null) {
                double kerning = font.getMetrics().getKerningValue(previousGlyphId, glyphId)
                        / glyph.getSourceResolution() * fontSize * resolutionCorrection;
                double advance = fontWidthToImageWidth(font.getMetrics().getGlyphWidth(previousGlyphId),
                        glyph.getSourceResolution(), fontSize, dpi);
                glyphXCoordinate += kerning + advance;
            }
            GeneralPath path = new GeneralPath();
            IGlyphRenderer renderer = new GlyphOutlineRenderer(new GlyphOutlinePainter(path));
            TransformationMatrix matrix = new TransformationMatrix(new double[] {
                    fontSize * resolutionCorrection, 0, 0, -fontSize * resolutionCorrection,
                    glyphXCoordinate, glyphYCoordinate
            });
            renderer.renderGlyph(font, glyphId, matrix);
            path.setWindingRule(GeneralPath.WIND_NON_ZERO);
            graphics.setPaint(textBrush);
            graphics.fill(path);
            previousGlyphId = glyphId;
        }
    } finally {
        graphics.dispose();
    }
    if (!ImageIO.write(outputBitmap, "png", new File(outputFile))) {
        throw new IOException("No PNG writer is available.");
    }
}

1. Crea metodo di utilità per calcolare la larghezza del carattere alla larghezza dell’immagine come mostrato nel campione di codice seguente

private static double fontWidthToImageWidth(double width, int fontSourceResolution,
        double fontSize, double dpi) {
    return width / fontSourceResolution * fontSize * (dpi / 72);
}

Chiamare la funzionalità di testo di rendering

Per utilizzare le implementazioni di cui sopra, il seguente codice di esempio può essere eseguito dal metodo principale di un’applicazione basata sulla console.

String firstFontPath = Paths.get(getDataDir(), "..", "TTF", "montserrat-bold.ttf")
        .normalize().toString();
String secondFontPath = Paths.get(getDataDir(), "..", "TTF", "LatoWeb-Regular.ttf")
        .normalize().toString();
TtfFont firstFont = (TtfFont) Font.open(new FontDefinition(FontType.TTF,
        new FontFileDefinition("ttf", new FileSystemStreamSource(firstFontPath))));
TtfFont secondFont = (TtfFont) Font.open(new FontDefinition(FontType.TTF,
        new FontFileDefinition("ttf", new FileSystemStreamSource(secondFontPath))));

String firstOutput = Paths.get(getOutputDir(), "hello1_montserrat_out.png").toString();
String secondOutput = Paths.get(getOutputDir(), "hello2_lato_out.png").toString();
drawText("Hello world", firstFont, 14, Color.WHITE, Color.BLACK, firstOutput);
drawText("Hello world", secondFont, 14, Color.YELLOW, Color.RED, secondOutput);