Drawing Functions in OpenCV - A Comprehensive Guide

Hi Guys! In this blog, we will explore the fundamentals of Drawing functions in OpenCV, including how to create lines, rectangles, circles, polygons, and text on images. With step-by-step explanations and practical examples, you'll learn how to customize colors, thickness, and positioning to create visually appealing graphics.

OpenCV, one of the most powerful computer vision libraries, provides a range of built-in functions to draw geometric shapes and add text overlays on images. Whether you're working on image annotation, object detection, or GUI development, mastering OpenCV’s drawing functions is essential for effective image processing and visualization.

By the end of this guide, you'll have a solid understanding of how to use OpenCV’s drawing capabilities to enhance your computer vision projects. Let's dive in!

Let's Code

# Our Setup, Import Libaries, Create our Imshow Function and Download our Images
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Define our imshow function 
def imshow(title = "Image", image = None, size = 6):
    w, h = image.shape[0], image.shape[1]
    aspect_ratio = w/h
    plt.figure(figsize=(size * aspect_ratio,size))
    plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
    plt.title(title)
    plt.show()

Understanding the Code for Displaying Images Using OpenCV and Matplotlib

Image processing is a crucial aspect of computer vision, and displaying images effectively is an essential step in analyzing visual data. The given Python code combines OpenCV and Matplotlib to create a custom function for displaying images with proper scaling and aspect ratio. Let’s break down each part of the code and understand its purpose.

Importing Required Libraries

import cv2
import numpy as np
from matplotlib import pyplot as plt

The first three lines import the necessary libraries. OpenCV (cv2) is used for image processing tasks, NumPy (np) provides support for handling multi-dimensional arrays, and Matplotlib (pyplot module) allows for visualization of images in an interactive or static manner.

cv2 is primarily responsible for reading, manipulating, and processing images.
numpy helps manage image arrays, as images are stored in matrix form.
pyplot from matplotlib is used to plot and display images in a way that maintains color fidelity (since OpenCV loads images in BGR format by default).

Defining the `imshow` Function

def imshow(title = "Image", image = None, size = 6):

Here, we define a function named imshow, which simplifies the process of displaying an image using Matplotlib. The function accepts three parameters:

title: A string that specifies the title of the image window (default is "Image").
image: The image to be displayed (default is None).
size: A scaling factor that determines the size of the displayed image (default is 6).

This function is useful because it automates image visualization while maintaining a proper aspect ratio.

Computing Aspect Ratio for Proper Display

w, h = image.shape[0], image.shape[1]
aspect_ratio = w / h

Here, we extract the height (w) and width (h) of the given image using image.shape. Since OpenCV represents images in the format (height, width, channels), shape[0] gives the number of rows (height), and shape[1] gives the number of columns (width).

The aspect ratio is then computed using w / h, ensuring that the image is not distorted when resized for display.

Configuring Matplotlib Figure Size

plt.figure(figsize=(size * aspect_ratio, size))

This line adjusts the figure size dynamically based on the aspect ratio of the image.

size * aspect_ratio determines the width of the figure.
size determines the height of the figure.

This approach ensures that the image is displayed in its correct proportions without stretching or compression.

Converting Image Format from BGR to RGB

plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))

OpenCV loads images in BGR (Blue-Green-Red) format, but Matplotlib expects images in RGB (Red-Green-Blue) format. To correctly display colors, we use cv2.cvtColor(image, cv2.COLOR_BGR2RGB), which converts the image from BGR to RGB before displaying it.

Setting the Title and Displaying the Image

plt.title(title)
plt.show()

plt.title(title): Sets the title of the image display window.
plt.show(): Renders and displays the image.

Why Use This Function?

The imshow function is a convenient way to display images in Jupyter Notebooks, scripts, or other interactive environments without manually adjusting the figure size or converting color formats. Unlike OpenCV’s cv2.imshow(), which requires explicit waits (cv2.waitKey()) and destroys windows (cv2.destroyAllWindows()), Matplotlib's approach works seamlessly in most environments and provides better visualization control.

# Create a black image using numpy to create and array of black 
image = np.zeros((512,512,3), np.uint8)

# Can we make this in black and white? grayscale
image_gray = np.zeros((512,512), np.uint8)

# Black would be the same as a greyscale or color image (same for white)
imshow("Black Canvas - RGB Color", image)
imshow("Black Canvas - Grayscale", image_gray)

Understanding Image Creation Using NumPy and OpenCV

In computer vision and image processing, creating blank images is often necessary for drawing operations, testing algorithms, or initializing an image canvas. The given Python code demonstrates how to generate black images using NumPy and display them with a custom imshow function. Let’s break it down step by step.

Creating a Black Image in RGB Format

image = np.zeros((512, 512, 3), np.uint8)

This line of code creates a black image of size 512×512 pixels with three color channels (RGB). Let’s analyze each part:

np.zeros((512,512,3), np.uint8):
- np.zeros((512,512,3)) generates a NumPy array filled with zeros, meaning all pixel values are set to 0.
- (512,512,3): Specifies an image of height = 512 pixels, width = 512 pixels, and 3 color channels (Red, Green, Blue).
- np.uint8: The datatype uint8 (unsigned 8-bit integer) ensures pixel values range from 0 to 255, which is the standard range for image data in OpenCV.

Since all pixel values are set to (0,0,0) (black in RGB format), this effectively creates a black canvas in color mode.

Creating a Black Image in Grayscale Format

image_gray = np.zeros((512,512), np.uint8)

This line creates a grayscale image of 512×512 pixels, but unlike the previous image, it has only one channel instead of three.

np.zeros((512,512)): Generates a 2D array with all zero values.
np.uint8: Ensures pixel values range from 0 to 255.

Since grayscale images contain only one intensity channel, each pixel has a single value representing brightness. Here, all pixel values are 0, meaning the entire image is black.

Displaying the Images

imshow("Black Canvas - RGB Color", image)
imshow("Black Canvas - Grayscale", image_gray)

The imshow function (which was defined earlier) is used to display both images using Matplotlib:

First Image - "Black Canvas - RGB Color"
- Displays the black image with three channels (RGB).
- Even though the image appears black, it still supports color modifications.
Second Image - "Black Canvas - Grayscale"
- Displays the black image in grayscale mode.
- Since it contains only intensity values, it cannot store color information.

Key Differences Between RGB and Grayscale Images

Feature	RGB Image	Grayscale Image
Number of Channels	3 (Red, Green, Blue)	1 (Grayscale Intensity)
Memory Usage	Higher (More Data)	Lower (Single Intensity Value)
Color Representation	Supports Colors	Only Black, White, and Shades of Gray
File Size	Larger (More Information)	Smaller
Processing Speed	Slower (More Data to Process)	Faster (Fewer Computations)

Why Use These Blank Images?

Blank images like these are commonly used in:

Drawing operations (e.g., drawing shapes using OpenCV).
Testing image processing algorithms (e.g., edge detection, filters).
Creating synthetic datasets for deep learning models.
Overlaying text and objects on an empty canvas.

Draw a line over our black square

# Note this is an inplace operation, meaning it changes the input image
# Unlike many other OpenCV functions that return a new image leaving the input unaffected
# Remember our image was the black canvas
cv2.line(image, (0,0), (511,511), (255,127,0), 5)

imshow("Black Canvas With Diagonal Line", image)

Drawing a Diagonal Line on an Image Using OpenCV

In computer vision and image processing, drawing shapes such as lines, circles, and rectangles is a fundamental technique used for annotation, debugging, and visualization. The given Python code demonstrates how to draw a diagonal line on an image using OpenCV's cv2.line() function and display the result using the custom imshow function. Let’s break it down step by step.

Drawing a Line Using `cv2.line()`

cv2.line(image, (0,0), (511,511), (255,127,0), 5)

This line of code draws a diagonal line from the top-left corner to the bottom-right corner of the image. Let’s analyze the function parameters in detail:

image: The target image on which the line will be drawn.
(0,0): The starting point of the line, which corresponds to the top-left corner of the image (X = 0, Y = 0).
(511,511): The ending point of the line, which corresponds to the bottom-right corner (X = 511, Y = 511).
(255,127,0): The color of the line in BGR format (Blue = 255, Green = 127, Red = 0). This means the line will have a cyan-like color.
5: The thickness of the line in pixels. Here, the line will be 5 pixels wide.

Displaying the Image

imshow("Black Canvas With Diagonal Line", image)

The imshow function (previously defined) is used to display the modified image. This function ensures that the image is properly visualized with the correct aspect ratio and color format.

The title "Black Canvas With Diagonal Line" is set to describe the displayed image.
The function converts the image from BGR to RGB (since OpenCV uses BGR by default, while Matplotlib expects RGB).

Understanding How `cv2.line()` Works

The coordinate system in OpenCV follows a Cartesian-like format, but with the origin (0,0) at the top-left of the image.

(0,0)  ----------------------------->  (Width - 1, 0)
        |                          
        |       Image (512x512)  
        |                          
        v  
(0,Height - 1) ------------------> (Width - 1, Height - 1)

In this case, (0,0) represents the top-left corner, and (511,511) represents the bottom-right corner. The cv2.line() function connects these two points with a colored line of the specified thickness.

Customizing the Line

You can modify the properties of the line to achieve different visual effects:

Changing the Color
- Example: (0,255,0) for a green line
- Example: (255,255,255) for a white line
Adjusting the Thickness
- Example: cv2.line(image, (0,0), (511,511), (255,127,0), 1) → Thinner line
- Example: cv2.line(image, (0,0), (511,511), (255,127,0), 10) → Thicker line
Drawing a Horizontal or Vertical Line
- Horizontal: cv2.line(image, (50, 250), (450, 250), (255, 0, 0), 5)
- Vertical: cv2.line(image, (250, 50), (250, 450), (0, 255, 0), 5)

The cv2.line() function is a simple yet powerful tool for drawing lines on images. By understanding how to specify coordinates, colors, and thickness, you can customize the appearance of the line as needed. This fundamental technique is frequently used in image processing, data visualization, and graphical applications.

Drawing Rectangles

cv2.rectangle(image, starting vertex, opposite vertex, color, thickness)

# Create our black canvas again because now it has a line in it
image = np.zeros((512,512,3), np.uint8)

# Thickness - if positive. Negative thickness means that it is filled
cv2.rectangle(image, (100,100), (300,250), (127,50,127), 10)
imshow("Black Canvas With Pink Rectangle", image)

Drawing a Rectangle on an Image Using OpenCV

In image processing, drawing geometric shapes like rectangles is a fundamental technique used for highlighting objects, creating annotations, and designing graphical overlays. The given Python code demonstrates how to create a black canvas and draw a rectangle on it using OpenCV’s cv2.rectangle() function. Let’s analyze the code in detail.

Creating a Black Canvas

image = np.zeros((512,512,3), np.uint8)

This line creates a blank black image of size 512×512 pixels with three color channels (RGB). Let’s break it down:

np.zeros((512,512,3)): Generates a NumPy array filled with zeros, meaning all pixel values are set to (0,0,0) (black color).
(512,512,3): Specifies an image of height = 512 pixels, width = 512 pixels, and 3 color channels (Red, Green, Blue).
np.uint8: Specifies the datatype, ensuring pixel values range from 0 to 255, which is standard for OpenCV image processing.

Since all pixel values are zero, the entire image will appear black.

Drawing a Rectangle on the Image

cv2.rectangle(image, (100,100), (300,250), (127,50,127), 10)

This function draws a rectangle on the image. Let’s break down its parameters:

image: The target image on which the rectangle will be drawn.
(100,100): The starting coordinate (x1, y1), which represents the top-left corner of the rectangle.
(300,250): The ending coordinate (x2, y2), which represents the bottom-right corner of the rectangle.
(127,50,127): The color of the rectangle in BGR format (Blue = 127, Green = 50, Red = 127). This will result in a pinkish-purple color.
10: The thickness of the rectangle's border, set to 10 pixels.

Since the thickness is positive, the function only draws the border of the rectangle. If the thickness were -1, OpenCV would fill the entire rectangle with the specified color.

Displaying the Image

imshow("Black Canvas With Pink Rectangle", image)

The imshow function is used to display the modified image:

The title "Black Canvas With Pink Rectangle" helps describe what the image contains.
The function automatically adjusts the aspect ratio for proper visualization.
The image is converted from BGR to RGB to ensure correct color representation in Matplotlib.

Understanding the Coordinate System in OpenCV

OpenCV’s coordinate system places the origin (0,0) at the top-left corner of the image.

(0,0)  -------------------------->  (Width - 1, 0)
        |                          
        |       Image (512x512)  
        |                          
        v  
(0,Height - 1) ------------------> (Width - 1, Height - 1)

(100,100): Represents the top-left corner of the rectangle.
(300,250): Represents the bottom-right corner of the rectangle.

The cv2.rectangle() function draws a bordered rectangle between these two points, ensuring that it maintains the given thickness.

Customizing the Rectangle

You can modify the properties of the rectangle to achieve different effects:

Changing the Color
- Example: (255,0,0) → Blue rectangle
- Example: (0,255,0) → Green rectangle
- Example: (0,0,255) → Red rectangle
Changing the Thickness
- Example: cv2.rectangle(image, (100,100), (300,250), (127,50,127), 2) → Thinner rectangle border
- Example: cv2.rectangle(image, (100,100), (300,250), (127,50,127), 20) → Thicker rectangle border
Filling the Rectangle
- If you want to fill the rectangle with color, use -1 instead of a thickness value:
```
cv2.rectangle(image, (100,100), (300,250), (127,50,127), -1)
```
- This fills the entire rectangle with pinkish-purple color instead of just drawing a border.

The cv2.rectangle() function is a powerful tool for drawing rectangles on images. By understanding how to specify coordinates, colors, thickness, and filling options, you can customize the shape for different applications. This technique is frequently used in image annotation, object detection, and graphical interface development.

Now let's draw some cirlcles?

cv2.cirlce(image, center, radius, color, fill)

image = np.zeros((512,512,3), np.uint8)

cv2.circle(image, (350, 350), 100, (15,150,50), -1) 
imshow("Black Canvas With Green Circle", image)

Drawing a Filled Circle on an Image Using OpenCV

Drawing geometric shapes on images is a fundamental skill in computer vision and image processing. Shapes like circles, rectangles, and lines are often used for object annotation, feature highlighting, and graphical overlays. In this blog, we will discuss how to create a black canvas and draw a filled circle on it using OpenCV’s cv2.circle() function.

Step 1: Creating a Black Canvas

image = np.zeros((512,512,3), np.uint8)

This line of code creates a black image with dimensions 512×512 pixels and three color channels (RGB). Here’s a breakdown of the parameters:

np.zeros((512,512,3)): Generates a NumPy array filled with zeros, meaning all pixel values are set to (0,0,0) (black color).
(512,512,3): Specifies an image with height = 512 pixels, width = 512 pixels, and 3 color channels (Red, Green, Blue).
np.uint8: Ensures pixel values range from 0 to 255, which is standard in OpenCV for image processing.

Since the array is filled with zeros, the image is entirely black.

Step 2: Drawing a Filled Circle

cv2.circle(image, (350, 350), 100, (15,150,50), -1)

This function draws a filled circle on the image. Let’s break down the function parameters:

image: The target image on which the circle will be drawn.
(350, 350): The center coordinate (x, y) of the circle. This places the center of the circle at (X = 350, Y = 350) on the image.
100: The radius of the circle, meaning the circle will extend 100 pixels from its center in all directions.
(15,150,50): The color of the circle in BGR format (Blue = 15, Green = 150, Red = 50). This creates a greenish shade for the circle.
-1: The thickness of the circle. When -1 is passed, OpenCV fills the entire circle with the specified color. If a positive thickness value were given, only the border would be drawn.

Step 3: Displaying the Image

imshow("Black Canvas With Green Circle", image)

The imshow function (defined earlier) is used to display the modified image using Matplotlib:

The title "Black Canvas With Green Circle" describes what the image contains.
The function ensures the image maintains the correct aspect ratio when displayed.
Since OpenCV reads images in BGR format, the function converts them to RGB format for correct color visualization in Matplotlib.

Understanding the Coordinate System in OpenCV

The coordinate system in OpenCV places the origin (0,0) at the top-left corner of the image:

(0,0)  ----------------------------->  (Width - 1, 0)
        |                          
        |       Image (512x512)  
        |                          
        v  
(0,Height - 1) ------------------> (Width - 1, Height - 1)

(350,350): The center of the circle is at (X = 350, Y = 350).
100: The radius determines how large the circle appears.
The function ensures that the circle does not exceed the image boundaries, as long as the radius is within the image size.

Customizing the Circle

You can modify the properties of the circle to achieve different effects:

Changing the Color
- Example: (0,0,255) → Red circle
- Example: (255,255,0) → Cyan circle
- Example: (0,255,255) → Yellow circle
Changing the Radius
- Example: cv2.circle(image, (350, 350), 50, (15,150,50), -1) → Smaller circle
- Example: cv2.circle(image, (350, 350), 150, (15,150,50), -1) → Larger circle
Drawing an Outline Instead of a Filled Circle
- If you want to draw only the border, specify a positive thickness value instead of -1:
```
cv2.circle(image, (350, 350), 100, (15,150,50), 5)
```
- This will create a circle with a 5-pixel-thick border instead of a filled circle.

The cv2.circle() function is a simple yet powerful tool for drawing circles on images. Whether you need a filled circle or an outlined one, this function provides complete flexibility in terms of positioning, color, and size. This technique is frequently used in computer vision, graphical applications, and real-time object tracking.

Polygons

cv2.polylines(image, points, Closed?, color, thickness)

image = np.zeros((512,512,3), np.uint8)

# Let's define four points
pts = np.array( [[10,50], [400,50], [90,200], [50,500]], np.int32)

# Let's now reshape our points in form  required by polylines
pts = pts.reshape((-1,1,2))

cv2.polylines(image, [pts], True, (0,0,255), 3)
imshow("Black Canvas with Red Polygon", image)

Drawing a Polygon on an Image Using OpenCV

In computer vision and image processing, drawing geometric shapes is an essential task used in object annotation, segmentation, and graphical overlays. This tutorial explains how to draw a polygon on a black canvas using OpenCV’s cv2.polylines() function. The polygon is formed using a set of predefined points, which are connected to create a closed shape.

Step 1: Creating a Black Canvas

image = np.zeros((512,512,3), np.uint8)

This line of code creates a black image of size 512×512 pixels with three color channels (RGB). Let’s break it down:

np.zeros((512,512,3)): Generates a NumPy array filled with zeros, meaning all pixel values are set to (0,0,0) (black color).
(512,512,3): Specifies an image of height = 512 pixels, width = 512 pixels, and 3 color channels (Red, Green, Blue).
np.uint8: Ensures that pixel values range from 0 to 255, which is standard in OpenCV for image processing.

Since all pixel values are zero, the image appears completely black.

Step 2: Defining Points for the Polygon

pts = np.array( [[10,50], [400,50], [90,200], [50,500]], np.int32)

This line defines the vertices (corner points) of the polygon. Each point is represented as an (x, y) coordinate:

[10,50] → The first point (x = 10, y = 50).
[400,50] → The second point (x = 400, y = 50).
[90,200] → The third point (x = 90, y = 200).
[50,500] → The fourth point (x = 50, y = 500).

These points form an irregular quadrilateral.

Step 3: Reshaping the Points

pts = pts.reshape((-1,1,2))

This line reshapes the pts array into the correct format for OpenCV’s cv2.polylines() function:

(-1,1,2):
- -1 allows automatic calculation of the number of points.
- 1 ensures each point is stored as a separate entity.
- 2 represents the x and y coordinates.

OpenCV expects polygon points to be in this reshaped format when passing them into cv2.polylines().

Step 4: Drawing the Polygon

cv2.polylines(image, [pts], True, (0,0,255), 3)

This function draws a polygon by connecting the specified points. Let’s break down its parameters:

image: The target image where the polygon will be drawn.
[pts]: The array containing the list of polygon points.
True: Specifies whether the shape should be closed (i.e., whether the last point should be connected back to the first).
- If False, the polygon will remain open.
(0,0,255): The color of the polygon in BGR format.
- (0,0,255) corresponds to red.
3: The thickness of the polygon's border (3 pixels).

Since True is passed as the third argument, OpenCV automatically connects the last point back to the first, forming a closed polygon.

Step 5: Displaying the Image

imshow("Black Canvas with Red Polygon", image)

The imshow function (defined earlier) is used to display the modified image using Matplotlib:

The title "Black Canvas with Red Polygon" describes what the image contains.
The function ensures the image maintains the correct aspect ratio when displayed.
Since OpenCV stores images in BGR format, the function converts them to RGB format for correct color visualization in Matplotlib.

Understanding the Coordinate System in OpenCV

OpenCV uses a Cartesian coordinate system, where the origin (0,0) is at the top-left corner of the image:

(0,0)  ----------------------------->  (Width - 1, 0)
        |                          
        |       Image (512x512)  
        |                          
        v  
(0,Height - 1) ------------------> (Width - 1, Height - 1)

The x-axis increases from left to right.
The y-axis increases from top to bottom.

Since the points [10,50], [400,50], [90,200], and [50,500] are within the 512×512 image boundary, OpenCV correctly plots and connects them.

Customizing the Polygon

1. Changing the Color

You can modify the polygon’s color by changing the BGR values:

(255,0,0) → Blue polygon.
(0,255,0) → Green polygon.
(255,255,0) → Cyan polygon.

2. Changing the Thickness

cv2.polylines(image, [pts], True, (0,0,255), 1) → Thinner polygon border.
cv2.polylines(image, [pts], True, (0,0,255), 5) → Thicker polygon border.

3. Creating an Open Polygon

To create an open polygon, set the third parameter to False:

cv2.polylines(image, [pts], False, (0,0,255), 3)

This prevents OpenCV from connecting the last point to the first.

The cv2.polylines() function is a powerful tool for drawing complex polygons on images. Whether you need to outline objects, create masks, or annotate images, understanding how to define points and connect them using OpenCV is an essential skill.

pts = np.array( [[10,50], [400,50], [90,200], [50,500]], np.int32)
pts.shape

(4, 2)

pts = pts.reshape((-1,1,2))
pts.shape

(4, 1, 2)

Adding text with cv2.putText

cv2.putText(image, 'Text to Display', bottom left starting point, Font, Font Size, Color, Thickness)

image = np.zeros((1000,1000,3), np.uint8)
ourString =  'Hello World!'
cv2.putText(image, ourString, (155,290), cv2.FONT_HERSHEY_SCRIPT_COMPLEX, 3, (40,200,0), 4)
imshow("Messing with some text", image)

Displaying Text on an Image Using OpenCV

Text plays an important role in image processing and computer vision applications. Whether it's labeling detected objects, adding captions to images, or displaying real-time data, text overlays enhance the information conveyed in an image. In this blog, we will explore how to write text on an image using OpenCV’s cv2.putText() function and display it using Matplotlib.

Step 1: Creating a Black Canvas

image = np.zeros((1000,1000,3), np.uint8)

This line creates a blank black image with dimensions 1000×1000 pixels and three color channels (RGB). Here’s a breakdown of its components:

np.zeros((1000,1000,3)): Generates a NumPy array filled with zeros, meaning all pixel values are set to (0,0,0) (black color).
(1000,1000,3): Specifies an image with height = 1000 pixels, width = 1000 pixels, and 3 color channels (Red, Green, Blue).
np.uint8: Ensures that pixel values range from 0 to 255, which is standard in OpenCV for image processing.

Since all pixels are initialized as zero, the image appears completely black.

Step 2: Defining the Text String

ourString = 'Hello World!'

This line defines a text string "Hello World!" that we want to display on the image. This string will be passed into OpenCV’s cv2.putText() function to be drawn on the image.

Step 3: Writing Text on the Image

cv2.putText(image, ourString, (155,290), cv2.FONT_HERSHEY_SCRIPT_COMPLEX, 3, (40,200,0), 4)

This function adds text to the image at a specified location using a chosen font style, size, color, and thickness. Let’s break down the parameters:

image: The target image where the text will be drawn.
ourString: The actual text string ("Hello World!") that will be displayed.
(155,290): The coordinates (x, y) of the bottom-left corner of the text.
- x = 155 places the text 155 pixels from the left of the image.
- y = 290 places the text 290 pixels from the top of the image.
- Text placement is based on the baseline of the first character, not the top-left corner.
cv2.FONT_HERSHEY_SCRIPT_COMPLEX: The font style used to render the text. OpenCV provides multiple fonts, such as:
- cv2.FONT_HERSHEY_SIMPLEX → Simple sans-serif font
- cv2.FONT_HERSHEY_COMPLEX → Complex serif font
- cv2.FONT_HERSHEY_SCRIPT_COMPLEX → Handwriting-style script font (used in this code)
3: The font scale, which determines the size of the text. A value of 3 makes the text large enough to be clearly visible.
(40,200,0): The text color in BGR format:
- Blue = 40
- Green = 200
- Red = 0
- This results in a greenish shade of text.
4: The thickness of the text in pixels. A thickness of 4 ensures the text appears bold and legible.

Step 4: Displaying the Image

imshow("Messing with some text", image)

The imshow() function (defined earlier) is used to display the modified image using Matplotlib:

The title "Messing with some text" describes the content of the image.
The function ensures the image maintains the correct aspect ratio when displayed.
Since OpenCV reads images in BGR format, imshow() converts them to RGB format for correct color visualization in Matplotlib.

Understanding Text Placement in OpenCV

In OpenCV, text positioning follows a coordinate system where the origin (0,0) is at the top-left corner of the image. The coordinates (x, y) specify the bottom-left corner of the text.

(0,0)  ----------------------------->  (Width - 1, 0)
        |                          
        |       Image (1000x1000)  
        |                          
        v  
(0,Height - 1) ------------------> (Width - 1, Height - 1)

The text’s baseline is placed at (155,290).
The actual text characters extend upwards from the baseline.

If text is not appearing correctly, adjusting the y-coordinate can help reposition it.

Customizing the Text Appearance

1. Changing the Font Style

You can modify the font style by using different OpenCV fonts:

cv2.FONT_HERSHEY_SIMPLEX    # Simple sans-serif  
cv2.FONT_HERSHEY_COMPLEX    # Complex serif  
cv2.FONT_HERSHEY_SCRIPT_COMPLEX  # Handwritten script (used in this example)  
cv2.FONT_HERSHEY_DUPLEX     # Similar to complex but with better readability  
cv2.FONT_HERSHEY_TRIPLEX    # More complex serif font  
cv2.FONT_HERSHEY_PLAIN      # Basic small font

2. Adjusting the Font Size

Increasing or decreasing the font scale changes the text size:

cv2.putText(image, "Small Text", (50,150), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,255,255), 2)
cv2.putText(image, "Large Text", (50,300), cv2.FONT_HERSHEY_SIMPLEX, 4, (0,255,255), 5)

1 → Small text
4 → Large text

3. Changing the Color

The text color can be modified using BGR values:

(255,0,0) → Blue text
(0,255,0) → Green text
(0,0,255) → Red text
(255,255,0) → Cyan text

Example:

cv2.putText(image, "Red Text", (100,400), cv2.FONT_HERSHEY_SIMPLEX, 3, (0,0,255), 4)

4. Changing the Thickness

A thicker text outline improves visibility:

cv2.putText(image, "Bold Text", (100,500), cv2.FONT_HERSHEY_SIMPLEX, 3, (255,255,255), 8)

2 → Thin text
8 → Bold text

Practical Applications of Text on Images

Object Detection: Annotating detected objects in images.
Image Labeling: Adding captions or labels to images.
Real-Time Applications: Displaying information in live video feeds.
User Interfaces: Creating GUI elements like buttons or tooltips.
Augmented Reality (AR): Overlaying virtual text on real-world images.

The cv2.putText() function is a powerful tool for adding textual information to images. Whether for annotating objects, labeling images, or displaying real-time data, this function provides complete flexibility in terms of positioning, font style, color, size, and thickness.

By experimenting with different fonts and colors, you can create visually appealing text overlays for various computer vision and image processing applications.

Wrapping Up

Throughout this discussion, we explored various fundamental drawing functions in OpenCV, including creating shapes and adding text to images. We started with generating a blank canvas using NumPy, followed by drawing essential geometric shapes such as lines, rectangles, circles, and polygons. Finally, we concluded with adding custom text to an image using cv2.putText() while understanding how font styles, colors, thickness, and positioning impact text appearance.

These basic drawing techniques are widely used in image processing and computer vision applications. Whether you are working on object detection, data visualization, augmented reality (AR), or GUI development, mastering these OpenCV functions will allow you to manipulate images dynamically.

The key takeaways from this discussion include:

Using NumPy to create blank images as a canvas.
Drawing lines, rectangles, circles, and polygons with cv2.line(), cv2.rectangle(), cv2.circle(), and cv2.polylines().
Adding custom text to images with cv2.putText().
Understanding how colors, font styles, and thickness impact shapes and text.
Using Matplotlib (imshow()) to display images correctly in Jupyter Notebooks or Python scripts.

By combining these functions, you can build interactive visual tools, overlay annotations on images, or even create simple graphic applications. Keep experimenting with different colors, sizes, and positions to gain deeper insights into image manipulation in OpenCV.

Mr. AI Engineer