Wrap and Render Multiline Text on Images Using Python&#s Pillow Library

Python image processing: Pillow library implements automatic line wrapping text annotation

Python has become the leading programming language in the field of image processing with its rich open source libraries. Pillow is one of the commonly used image processing libraries. It is simple, easy to use and has complete documentation. It is often used for operations such as image scaling, cropping, brightness adjustment and annotation.

However, Pillow has a problem with text annotation: when the text exceeds the width of the text box, it will not wrap automatically. The Pillow library itself does not provide this function, and we need to write the logic implementation ourselves.

This tutorial will demonstrate how to use the Pillow library to add a word-wrap text box in Python to achieve correct image text annotation. The final effect is as follows:

The picture above is a screenshot of my Dev.to profile, we will use this as an example to explain. The green text box is the text annotation we added.

Preparation

This tutorial requires you to have basic Python programming knowledge, such as conditional statements (if, else), for loops, etc. You'll also need the following tools and software:

1. Python3 : Interpreter for running Python scripts.
2. Pillow: Python image processing library.
3. Code editor: such as Pycharm, VScode, etc.

Create new project

Follow these steps to create a new project:

A. Create a new folder using terminal/command line:

<code class="language-bash">mkdir image_annotation</code>

B. Use pip to install virtualenv (skip this step if you have already installed it):

<code class="language-bash">pip install virtualenv</code>

C. Switch the working directory to the image_annotation folder:

<code class="language-bash">cd image_annotation</code>

D. Create a new virtual environment:

<code class="language-bash">virtualenv env</code>

E. Activate virtual environment (use command prompt for Windows):

Windows:

<code class="language-bash">.\env\Scripts\activate</code>

Linux/macOS:

<code class="language-bash">source env/bin/activate</code>

F. Use pip to install the Pillow library:

<code class="language-bash">pip install pillow</code>

Open the project in the code editor and create a new Python file named script.py in the project folder.

Prepare base image

The image you want to annotate is the base image. Open and prepare the image using Pillow's ImageDraw module. Write the following code in the script.py file:

<code class="language-python">from PIL import Image, ImageDraw, ImageFont
image_file = "path_to_image"  # 请替换为您的图片路径

# 打开图像
image = Image.open(image_file)

# 初始化ImageDraw
draw = ImageDraw.Draw(image)</code>

Add image annotation

Pillow can add plain text and text boxes with background filling. The text can be single line or multiple lines. This tutorial focuses on how to add a multi-line text box.

The

ImageDraw.multiline_text() method can add multiple lines of plain text, but no background padding. ImageDraw.rectangle() method can add a text box with background fill.

Add the following code in the script.py file:

<code class="language-bash">mkdir image_annotation</code>

This code sets the text, font, and text box width. The x and y variables represent the starting point of the drawing, and end_x and end_y represent the coordinates of the lower right corner of the text box. The width and height of the text box are 200 and 50 respectively.

The

ImageDraw.rectangle() and ImageDraw.multiline_text() methods are used to draw text boxes and multi-line text respectively. The image.show() method is used to display the processed image. You can save the image using image.save("new_image.png"). The results are as follows:

There is still a problem with the annotation in the picture above, and the multi-line text does not wrap automatically. The next section explains how to solve this problem.

Realize automatic line wrapping

Line break character n is used to specify the line break position. In the previous example, the content after the newline character n will wrap. But in practical applications, the text length is usually dynamic and it is difficult to determine the position of the newline character.

The

attribute of ImageDrawPillow's .textlength() module can calculate the text length and compare it with the text box width to determine the line break position.

Create a new function named script.py at the top of the wrap_text() file (after the import statement), containing the word-wrap logic:

<code class="language-bash">pip install virtualenv</code>

Add the following code after the text, font, max_width variables:

<code class="language-bash">cd image_annotation</code>

Replace the draw.multiline_text() method with the following code:

<code class="language-bash">virtualenv env</code>

Remove newlines from the text n and run the code:

<code class="language-bash">.\env\Scripts\activate</code>

The running result shows that the text still exceeds the height of the text box. While the text automatically adjusts to the text box width, the text box height is fixed, causing the text to overflow.

Set dynamic text box height

The height of the dynamic text box is determined based on the number of text lines. The first step is to change the text box's end_y variable to a dynamic value:

<code class="language-bash">source env/bin/activate</code>

This formula was arrived at after many experiments and it seems to be the best solution for getting dynamic textbox height in this use case. wrapped_linesThe list contains all the lines to be added to the text box, so the length of the list is equal to the total number of lines of the text box.

The results are as follows:

You may need to multiply the total number of rows by different values ​​to get the perfect solution for your use case.

Add text padding

The text is too close to the edge of the text box, affecting readability and style. You can solve this problem by adding padding inside the text box. Add a new script.py variable in the padding file and change the text box size:

<code class="language-bash">pip install pillow</code>

This code allows for spacing between the text and the edges of the text box.

Add pointer

The pointer can conveniently indicate the part of the image that the annotation/label refers to. The pointer should be before the label. This means that the pointer will be drawn at the current position of the text box, and the text box will move to the right.

Therefore, the x-axis of the text box will be associated with the new box_x variable. This change must also be reflected in other variables using the textbox x-axis. Here is the updated code:

<code class="language-bash">mkdir image_annotation</code>

In the above code, the ImageDraw.circle() method (where 10 is the radius) is used to draw the pointer at the specified point. box_xThe variable is the new value of the x-axis of the text box.

Full code

The following is the complete code of the script.py file:

<code class="language-bash">pip install virtualenv</code>

Conclusion

Image processing is not always as difficult as it seems. Although some image processing libraries cannot directly solve your problem with their modules, you can use existing modules to implement a specific solution for your use case. That’s the beauty of coding – being able to solve problems with custom and specific solutions.

In this tutorial, you learned how to use Python’s Pillow library to annotate images, add word-wrapped multi-line text boxes, and more. You also learned how to write mathematical formulas that can help you with image processing.

Please refer to the Pillow documentation for details on the modules used.

The above is the detailed content of Wrap and Render Multiline Text on Images Using Python&#s Pillow Library. For more information, please follow other related articles on the PHP Chinese website!