Forem: Vinay Jain

How Haptik generates images on the fly with Python - Part 2

Vinay Jain — Sun, 08 Apr 2018 17:24:18 +0000

In the first post of this series, I introduced you to the basics of text drawing in Python by adding a greeting text on an image.
I also highlighted examples of how I further extended this functionality to create some complex images at work. If you haven’t already read the first part of this series (How Haptik generates images on the fly with Python), I recommend you take a glance at it first, to get a better understanding of this post.

For now, we know how to draw text, change the font, and position the text on the image. In this post, we’ll discover how to draw multi-line text and also discuss the challenges of doing so.

Multiline Text

Often, while generating images, we come across situations where the text doesn’t fit in a single line. Python Pillow is not helpful here as it doesn’t automatically draw & push the text to a new line. In order to do this manually, we need to calculate the width and height of the text.

With the text-width, we determine when we need to move to the next line and with the text-height, we can figure how much space should be left in between the two lines:

The idea is to split the long sentences into multiple shorter sentences and draw each of these, one by one at the correct positions thereby making it look like a multi-line text. To split a longer line, we‘ll use a Pillow function to calculate the size of the text passed to it as one of the parameters.

Calculate text width

For convenience, I’ve created a method text_wrap() to explain the line-split logic:

from PIL import Image
from PIL import ImageFont
from PIL import ImageDraw

def text_wrap(text, font, max_width):
    lines = []
    # If the width of the text is smaller than image width
    # we don't need to split it, just add it to the lines array
    # and return
    if font.getsize(text)[0] <= max_width:
        lines.append(text) 
    else:
        # split the line by spaces to get words
        words = text.split(' ')  
        i = 0
        # append every word to a line while its width is shorter than image width
        while i < len(words):
            line = ''         
            while i < len(words) and font.getsize(line + words[i])[0] <= max_width:                
                line = line + words[i] + " "
                i += 1
            if not line:
                line = words[i]
                i += 1
            # when the line gets longer than the max width do not append the word, 
            # add the line to the lines array
            lines.append(line)    
    return lines


def draw_text(text):    
    # open the background file
    img = Image.open('background.png')

    # size() returns a tuple of (width, height) 
    image_size = img.size 

    # create the ImageFont instance
    font_file_path = 'fonts/Avenir-Medium.ttf'
    font = ImageFont.truetype(font_file_path, size=50, encoding="unic")

    # get shorter lines
    lines = text_wrap(text, font, image_size[0])
    print lines # ['This could be a single line text ', 'but its too long to fit in one. ']


if __name__ == __main__:
    draw_text("This could be a single line text but its too long to fit in one.")

This function expects three parameters – the text to draw, an ImageFont class instance and the width of the background image on which the text is to be drawn.

The logic is pretty straightforward:

Check, if the sentence can fit in one line then just return it without splitting, else:
Split the sentence using spaces to fetch the words in it
Create shorter lines by appending words while the width is smaller than the image width

When we run this script it returns an array containing 2 shorter lines which fit within the width of the background image.

To draw these lines on the image we have to calculate the correct vertical position of each line.

Calculate Text Height

Whenever we write text, there is an equal amount of space between two lines. For example in this post, the lines have the constant spaces between them. While building this library I faced an issue of varying spaces with most of the input text:

text = "This could be a single line text but it can't fit in one line."
lines = text_wrap(lines, font)

for line in lines:
    print font.getsize(line)[1]

# Output
# 62
# 51

Finding correct height for characters like g, j, p, q, y which are drawn below the Baseline and b, d, f, h, k, l which are drawn above the Median is a little tedious due to varying heights.

The best way to get the correct height of the text is to simply calculate the total height of “hg”. This trick works because h and g cover the height range of all the English characters.

For languages other than English, you might have to use different characters in place of h & g.


text = "This could be a single line text but it can't fit in one line."
lines = text_wrap(lines, font)

line_height = font.get_size('hg')[1]
print line_height

# Output
# 62

Since we have our wrapped/short lines and also the text height we can draw these on the image. We can do this by keeping a reference to the vertical position of the previously drawn line and then adding to it the line height to calculate the vertical position of the new line:


text = "This could be a single line text but its too long to fit in one."
lines = text_wrap(text, font, image_size[0])
line_height = font.getsize('hg')[1]

x = 10
y = 20
for line in lines:
    # draw the line on the image
    draw.text((x, y), line, fill=color, font=font)

    # update the y position so that we can use it for next line
    y = y + line_height
# save the image
img.save('word2.png', optimize=True)

This will output an image like this:

The text in the latter images looks much better and readable. At Haptik, we believe in experimentation and finding out the best possible way to solve problems. The above is one such example. In my next Blog post, I will be writing about how to center align text horizontally and vertically in an image using Python.

Think I did a good job? Let me know in the comments below.

This post was originally written on the Haptik Tech Blog.

How Haptik generates images on the fly with Python

Vinay Jain — Mon, 12 Mar 2018 11:26:18 +0000

Computer graphics teaches us how a pixel on a screen can be manipulated to draw beautiful shapes, artistic typography, eye-catching illustrations, ‘make-me-look-good’ photo-filters and a lot more. Hardware manufacturers, researchers, software developers work together to build great products: smartphones, smartwatches, smart TVs, cameras all with the study of computer graphics.

Despite the fact that computer graphics has evolved so fast and the development of software like Adobe Photoshop, Adobe Illustrator, Sketch has made our lives easier to a great extent, we still cannot generate images on-the-fly with them. In order to do that, we’ll need to reach a level where there is no drag and drop, no fancy select-all-make-bold keyboard shortcuts, no cropping and no copying-pasting.

And we cannot get there by time-travel, but surely with code!

Getting Started

Come along, open your favorite text editor, follow me and I’ll help you draw dynamic text data on images. I assume you have Python and pip installed on your computer, but if not, follow the steps in the links to set up the development environment. After you’ve done setting up, from the shell, execute the below command to install Pillow (more details here) and its dependencies.

pip install pillow

As you have installed all the dependencies, let's move forward and write some code. Pillow is an extensive library, but for our purpose, we’ll be using the following classes:

Image: to create an image object for our greeting background
ImageDraw: creates a drawing context
ImageFont: font of the text we will be drawing on the greeting

Let’s take the following background image and initialize it with the following code:

# import required classes

from PIL import Image, ImageDraw, ImageFont

# create an Image object with the input image

image = Image.open('background.png')

# initialize the drawing context with
# the image object as background

draw = ImageDraw.Draw(image)

For creating ImageFont objects we also need font(ttf, otf) files, you can use any font of your choice, here I’ll be using the Roboto font which can be downloaded from the Google Fonts GitHub repo.


# create font object with the font file and specify
# desired size

font = ImageFont.truetype('Roboto-Bold.ttf', size=45)

# starting position of the message

(x, y) = (50, 50)
message = "Happy Birthday!"
color = 'rgb(0, 0, 0)' # black color

# draw the message on the background

draw.text((x, y), message, fill=color, font=font)
(x, y) = (150, 150)
name = 'Vinay'
color = 'rgb(255, 255, 255)' # white color
draw.text((x, y), name, fill=color, font=font)

# save the edited image

image.save('greeting_card.png')

Below is what you get after executing the above code:

With some fonts, you might have to pass an optional parameter encoding which tells the ImageFont module which encoding to use while opening the font file.

Computer graphics have an inverted coordinate system, the origin(0, 0) that lies at the top-left corner of the image. x here represents the distance of the text box from the left (x=0) and y represents the distance from the top (y=0).

While you save the image, you can pass optional parameters like optimize and quality to control the size of the output image.

image.save('optimized.png', optimize=True, quality=20)

This generates an output image optimized.png with reduced quality but smaller size.

Where Are We Using Pillow With Python?

While at work, I recently developed a feature which demanded the creation of a leaderboard image on-the-fly, with user-specific quiz score data. And just with a few lines of code, I was able to create an image like this:

Voila! It looked great and we decided to use the idea of creating images on-the-go, for other use-cases as well. We currently use Pillow to generate images for Jokes, Motivational Quotes, Horoscopes, Word of the Day etc. in real time, and with data from different API responses.

The code we used in this post is not sufficient to draw text boxes as shown in the images above. I’ll be writing another post which will focus on text alignment, splitting long text into multiple lines, controlling space between two lines and more.

I recently read a post by @ben in which he wrote about how Dev.to generates social images dynamically. I realized I had done something similar at work so why not share with the community.

Please do give me your feedback if any in the comments section below.

This post was originally written for Haptik Tech Blog.