Representación de texto usando fuente Type1 | Java
Contents
[
Hide
Show
]Representación de texto
Para representar texto, el subsistema de Renderizado requiere la implementación de la interfaz Aspose.Font.Rendering.IGlyphOutlinePainter para dibujar glifos. Esto se puede lograr mediante los siguientes pasos.
- Cree el método
DrawText()que dibuja el texto especificado en el objeto System.Drawing.Bitmap y guarda el mapa de bits resultante en el disco. Esto incluirá los siguientes pasos:
- Iterar todos los símbolos en la cadena de texto.
- Obtenga un identificador de glifo para cada símbolo procesado: gid.
- Crear un objeto de tipo GlyphOutlinePainter que es requerido por el subsistema de representación para dibujar el glifo actual.
- Cree un objeto de tipo Aspose.Font.Renderers.GlyphOutlineRenderer y pase el objeto recién creado de tipo GlyphOutlinePainter al constructor de GlyphOutlineRenderer. Este objeto GlyphOutlineRenderer tenía como objetivo representar el glifo especificado.
- Renderiza el glifo procesado actual usando el método GlyphOutlineRenderer.RenderGlyph(). El objeto Aspose.Fonts.Matrix se utiliza para especificar las coordenadas del glifo. El glifo a renderizar se especifica mediante el parámetro gid.
Pasos auxiliares para esta estrategia
- La coordenada del glifo para el eje ‘Y’ es constante para este fragmento de código.
- La coordenada de glifo para el eje ‘X’ se calcula para cada glifo procesado.
- Tanto las coordenadas ‘X’ como ‘Y’ se pasan al objeto Aspose.Fonts.Matrix que utiliza GlyphOutlineRenderer para dibujar glifos.
- La distancia entre los glifos recién procesados y los anteriores se calcula en cada paso de iteración. Esta distancia afecta a cada coordenada ‘X’ de glifo.
- El objeto de tipo GlyphOutlinePainter dibuja glifos con la ayuda de GlyphOutlinePainter no directamente en Bitmap, sino en el objeto GraphicsPath, que se pasó al constructor de GlyphOutlinePainter, por lo que usamos el objeto de tipo System.Drawing.Graphics para dibujar GraphicsPath en Bitmap.
- Método FontWidthToImageWith() que calcula el ancho del glifo para el sistema de coordenadas de mapa de bits.
La implementación es como se ilustra a continuación.
1private static final class Type1GlyphOutlinePainter implements IGlyphOutlinePainter {
2 private final GeneralPath path;
3
4 private Type1GlyphOutlinePainter(GeneralPath path) {
5 this.path = path;
6 }
7
8 @Override
9 public void moveTo(MoveTo moveTo) {
10 path.moveTo(moveTo.getX(), moveTo.getY());
11 }
12
13 @Override
14 public void lineTo(LineTo lineTo) {
15 path.lineTo(lineTo.getX(), lineTo.getY());
16 }
17
18 @Override
19 public void curveTo(CurveTo curveTo) {
20 path.curveTo(curveTo.getX1(), curveTo.getY1(), curveTo.getX2(), curveTo.getY2(),
21 curveTo.getX3(), curveTo.getY3());
22 }
23
24 @Override
25 public void closePath() {
26 path.closePath();
27 }
28} 1private static void drawText(String text, IFont font, double fontSize,
2 Paint backgroundBrush, Paint textBrush, String outputFile) throws IOException {
3 GlyphId[] glyphIds = new GlyphId[text.length()];
4 for (int i = 0; i < text.length(); i++) {
5 glyphIds[i] = font.getEncoding().decodeToGid(text.charAt(i));
6 }
7 double dpi = 300;
8 double resolutionCorrection = dpi / 72;
9 BufferedImage outputBitmap = new BufferedImage(960, 720, BufferedImage.TYPE_INT_RGB);
10 Graphics2D graphics = outputBitmap.createGraphics();
11 try {
12 graphics.setPaint(backgroundBrush);
13 graphics.fillRect(0, 0, outputBitmap.getWidth(), outputBitmap.getHeight());
14 graphics.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
15 GlyphId previousGlyphId = null;
16 double glyphXCoordinate = 0;
17 double glyphYCoordinate = fontSize * resolutionCorrection;
18 for (GlyphId glyphId : glyphIds) {
19 if (glyphId == null) {
20 continue;
21 }
22 Glyph glyph = font.getGlyphAccessor().getGlyphById(glyphId);
23 if (glyph == null) {
24 continue;
25 }
26 if (previousGlyphId != null) {
27 double kerning = font.getMetrics().getKerningValue(previousGlyphId, glyphId)
28 / glyph.getSourceResolution() * fontSize * resolutionCorrection;
29 double advance = fontWidthToImageWidth(font.getMetrics().getGlyphWidth(previousGlyphId),
30 glyph.getSourceResolution(), fontSize, dpi);
31 glyphXCoordinate += kerning + advance;
32 }
33 GeneralPath path = new GeneralPath();
34 IGlyphRenderer renderer = new GlyphOutlineRenderer(new Type1GlyphOutlinePainter(path));
35 TransformationMatrix matrix = new TransformationMatrix(new double[] {
36 fontSize * resolutionCorrection, 0, 0, -fontSize * resolutionCorrection,
37 glyphXCoordinate, glyphYCoordinate
38 });
39 renderer.renderGlyph(font, glyphId, matrix);
40 path.setWindingRule(GeneralPath.WIND_NON_ZERO);
41 graphics.setPaint(textBrush);
42 graphics.fill(path);
43 previousGlyphId = glyphId;
44 }
45 } finally {
46 graphics.dispose();
47 }
48 if (!ImageIO.write(outputBitmap, "png", new File(outputFile))) {
49 throw new IOException("No PNG writer is available.");
50 }
51}- Cree un método de utilidad para calcular el ancho de la fuente con respecto al ancho de la imagen como se muestra en el ejemplo de código siguiente
1private static double fontWidthToImageWidth(double width, int fontSourceResolution,
2 double fontSize, double dpi) {
3 return width / fontSourceResolution * fontSize * (dpi / 72);
4}Llamar a la funcionalidad de renderizado de texto
Para utilizar las implementaciones anteriores, se puede ejecutar el siguiente código de muestra desde el método Main de una aplicación basada en consola.
1String fileName = Paths.get(getDataDir(), "..", "Type1", "courier.pfb").normalize().toString();
2FontDefinition fd = new FontDefinition(FontType.Type1,
3 new FontFileDefinition("pfb", new FileSystemStreamSource(fileName)));
4Type1Font font = (Type1Font) Font.open(fd);
5
6String firstOutput = Paths.get(getOutputDir(), "hello1_type1_out.png").toString();
7String secondOutput = Paths.get(getOutputDir(), "hello2_type1_out.png").toString();
8drawText("Hello world", font, 14, Color.WHITE, Color.BLACK, firstOutput);
9drawText("Hello world", font, 14, Color.YELLOW, Color.RED, secondOutput);