Adding Text to an Image in Java

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

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.