Adding Text to an Image in Java

最后修改: 2023-05-09T11:26:09+00:00

    1. Overview

    Sometimes we need to add some text to an image or a set of images. Doing this manually is easy using an image editing tool. But when we want to add the same text in the same way to a significant number of pictures, it would be very useful to do this programmatically.

    In this quick tutorial, we’re going to learn how to add some text to images using Java.

    2. Adding Text to an Image

    To read an image and add some text, we can use different classes. In the subsequent sections, we’re going to see a couple of options.

    2.1. ImagePlus and ImageProcessor

    First, let’s see how to use the classes ImagePlus and ImageProcessor that are available in the ImageJ library. To use this library we need to include this dependency in our project:

    <dependency>
    <groupId>net.imagej</groupId>
    <artifactId>ij</artifactId>
    <version>1.51h</version>
</dependency>

    To read the image we’ll use the openImage static method. The result of this method will be stored in memory using an ImagePlus object:

    ImagePlus image = IJ.openImage(path);

    Once we have the image loaded into memory, let’s add some text to it using the class ImageProcessor:

    Font font = new Font("Arial", Font.BOLD, 18);

ImageProcessor ip = image.getProcessor();
ip.setColor(Color.GREEN);
ip.setFont(font);
ip.drawString(text, 0, 20);

    With this code, what we’re doing is adding the specified text in green at the top left of the image. Note that we set the position using the second and third arguments of the drawString method which represent the number of pixels from the left and top respectively.

    2.2. BufferedImage and Graphics

    Next, we’re going to see how we can achieve the same result using the classes BufferedImage and Graphics. The standard build of Java includes these classes, so there’s no need for additional libraries.

    The same way we used openImage of ImageJ, we’re going to use the read method available in ImageIO:

    BufferedImage image = ImageIO.read(new File(path));

    Once we have the image loaded in memory, let’s add some text to it using the class Graphics:

    Font font = new Font("Arial", Font.BOLD, 18);

Graphics g = image.getGraphics();
g.setFont(font);
g.setColor(Color.GREEN);
g.drawString(text, 0, 20);

    As we can see, both alternatives are very similar in the way are used. In this case, the second and the third arguments of the method drawString are specified in the same way that we’ve done for the ImageProcessor method.

    2.3. Draw Based on AttributedCharacterIterator

    The method drawString available in Graphics allows us to print the text using an AttributedCharacterIterator. This means that instead of using a plain String, we could use text with some properties associated. Let’s see an example:

    Font font = new Font("Arial", Font.BOLD, 18);

AttributedString attributedText = new AttributedString(text);
attributedText.addAttribute(TextAttribute.FONT, font);
attributedText.addAttribute(TextAttribute.FOREGROUND, Color.GREEN);

Graphics g = image.getGraphics();
g.drawString(attributedText.getIterator(), 0, 20);

    This way of printing the text gives us the chance to associate the format directly with the String, which is cleaner than changing Graphics object properties whenever we want to change the format.

    3. Text Alignment

    Now that we’ve learned how to add a simple text in the top left of an image let’s see now how we can add this text in certain positions.

    3.1. Centered Text

    The first type of alignment that we’re going to tackle is centering the text. To dynamically set the correct position where we want to write the text, we need to figure out some information:

    • Image size
    • Font size

    This information can be obtained very easily. In the case of the image size, this data can be accessed through the methods getWidth and getHeight of the BufferedImage object. On the other hand, to get the data related to the font size we need to use the object FontMetrics.

    Let’s see an example where we calculate the correct position for our text and draw it:

    Graphics g = image.getGraphics();

FontMetrics metrics = g.getFontMetrics(font);
int positionX = (image.getWidth() - metrics.stringWidth(text)) / 2;
int positionY = (image.getHeight() - metrics.getHeight()) / 2 + metrics.getAscent();

g.drawString(attributedText.getIterator(), positionX, positionY);

    3.2. Text Aligned in the Bottom Right

    The next type of alignment that we’re going to see is the bottom right. In this case, we need to dynamically get the correct positions:

    int positionX = (image.getWidth() - metrics.stringWidth(text));
int positionY = (image.getHeight() - metrics.getHeight()) + metrics.getAscent();

    3.3. Text Located in the Top Left

    Finally, let’s see how to print our text in the top left:

    int positionX = 0;
int positionY = metrics.getAscent();

    The rest of the alignments can be deduced from the three we’ve seen.

    4. Adapting Text Size Based on Image

    When we draw the text in the image, we might find that this text exceeds the size of the image. To solve this, we have to adapt the size of the font that we’re using based on the image size.

    First, we need to obtain the expected width and height of the text using the base font. In order to achieve this, we’ll make use of the classes FontMetrics, GlyphVector, and Shape.

    FontMetrics ruler = graphics.getFontMetrics(baseFont);
GlyphVector vector = baseFont.createGlyphVector(ruler.getFontRenderContext(), text);
    
Shape outline = vector.getOutline(0, 0);
    
double expectedWidth = outline.getBounds().getWidth();
double expectedHeight = outline.getBounds().getHeight();

    The next step is to check if the resize of the font is necessary. For this purpose, let’s compare the expected size of the text and the size of the image:

    boolean textFits = image.getWidth() >= expectedWidth && image.getHeight() >= expectedHeight;

    Finally, if our text doesn’t fit in the image, we have to reduce the font size. We’ll use the method deriveFont for that:

    double widthBasedFontSize = (baseFont.getSize2D()*image.getWidth())/expectedWidth;
double heightBasedFontSize = (baseFont.getSize2D()*image.getHeight())/expectedHeight;

double newFontSize = widthBasedFontSize < heightBasedFontSize ? widthBasedFontSize : heightBasedFontSize;
newFont = baseFont.deriveFont(baseFont.getStyle(), (float)newFontSize);

    Note that we need to obtain the new font size based on both width and height and apply the lowest of them.

    5. Summary

    In this article, we’ve seen how to write text in an image using different methods.

    We’ve also learned how to dynamically get the position where we want to print our text based on the image size and the font properties.

    At last, we’ve seen how to adapt the font size of the text in case it exceeds the size of the image where we are drawing it.

    As always, the full source code of the article is available over on GitHub.