Tag Archives: cv2.morphologyEx

Understanding Structuring Element with Trackbars

As we already discussed that the most important thing in morphological image processing is the Structuring element. This is used to probe an image for finding the region of interest. Different shapes and sizes of SE will produce a different result. Thus it becomes vital to have a good grasp on this for better understanding of morphological image processing. In this blog, let’s create trackbars which makes it really easy to visualize the result for different values. So, let’s get started.

Steps:

Load the image and create a window to attach trackbars
Specify the morphological operations and Structuring elements
Create the trackbars and the callback function

import cv2
import numpy as np

# Load the image
src = cv2.imread('D:/downloads/g1.png')
# Create a window to attach trackbars
title_window = 'Morphology Operations'
cv2.namedWindow(title_window)

# Specify the morphological operations and Structuring elements
morph_op_dic = {0: 'ERODE', 1: 'DILATE', 2: 'OPEN', 3: 'CLOSE', \
                4: 'GRADIENT', 5: 'TOPHAT', 6: 'BLACKHAT', 7: 'HITMISS'}
element_dic = {0: 'RECT', 1: 'CROSS', 2: 'ELLIPSE'}

# Define callback function
def morphology_operations(val):
    # get current trackbar position
    morph_operator = cv2.getTrackbarPos('Operator', title_window)
    kernel_size = cv2.getTrackbarPos('kernel', title_window)
    val_type = cv2.getTrackbarPos('SE', title_window)
    iter_num = cv2.getTrackbarPos('iterations', title_window)
    # create structuring element
    element = cv2.getStructuringElement(val_type, (2*kernel_size + 1, 2*kernel_size+1))
    # apply morphological operation
    dst = cv2.morphologyEx(src, morph_operator, element,iterations=iter_num)
    # Display the operation and structuring element
    font = cv2.FONT_HERSHEY_SIMPLEX
    cv2.putText(dst,'Op:{}, SE: {}'.format(morph_op_dic[morph_operator],element_dic[val_type]),(10,40), font, 0.5,(0,255,255),1,cv2.LINE_AA)
    cv2.imshow(title_window, dst)
    
# Create Trackbars
cv2.createTrackbar('Operator', title_window , 0, 7, morphology_operations)
cv2.createTrackbar('SE', title_window , 0, 2, morphology_operations)
cv2.createTrackbar('kernel', title_window , 0, 10, morphology_operations)
cv2.createTrackbar('iterations', title_window , 0, 10, morphology_operations)

# Instantiate the function
morphology_operations(0)
cv2.waitKey(0)

import cv2

import numpy as np

# Load the image

src = cv2.imread('D:/downloads/g1.png')

# Create a window to attach trackbars

title_window = 'Morphology Operations'

cv2.namedWindow(title_window)

# Specify the morphological operations and Structuring elements

morph_op_dic = {0: 'ERODE', 1: 'DILATE', 2: 'OPEN', 3: 'CLOSE', \

4: 'GRADIENT', 5: 'TOPHAT', 6: 'BLACKHAT', 7: 'HITMISS'}

element_dic = {0: 'RECT', 1: 'CROSS', 2: 'ELLIPSE'}

# Define callback function

def morphology_operations(val):

# get current trackbar position

morph_operator = cv2.getTrackbarPos('Operator', title_window)

kernel_size = cv2.getTrackbarPos('kernel', title_window)

val_type = cv2.getTrackbarPos('SE', title_window)

iter_num = cv2.getTrackbarPos('iterations', title_window)

# create structuring element

element = cv2.getStructuringElement(val_type, (2*kernel_size + 1, 2*kernel_size+1))

# apply morphological operation

dst = cv2.morphologyEx(src, morph_operator, element,iterations=iter_num)

# Display the operation and structuring element

font = cv2.FONT_HERSHEY_SIMPLEX

cv2.putText(dst,'Op:{}, SE: {}'.format(morph_op_dic[morph_operator],element_dic[val_type]),(10,40), font, 0.5,(0,255,255),1,cv2.LINE_AA)

cv2.imshow(title_window, dst)

# Create Trackbars

cv2.createTrackbar('Operator', title_window , 0, 7, morphology_operations)

cv2.createTrackbar('SE', title_window , 0, 2, morphology_operations)

cv2.createTrackbar('kernel', title_window , 0, 10, morphology_operations)

cv2.createTrackbar('iterations', title_window , 0, 10, morphology_operations)

# Instantiate the function

morphology_operations(0)

cv2.waitKey(0)

This will produce the following output

Play with the trackbars to get a feel about the morphological operations. That’s all for this blog. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time

Thinning and Thickening

1 Reply

In the previous blog, we discussed Hit-or-Miss transformation, that is used for finding desired patterns in an image. In this blog, we will discuss various applications of Hit-or-miss transform such as thinning, thickening, etc. So, let’s get started.

Thinning

This is somewhat similar to erosion or opening operation that we discussed earlier. As clear from the name, this is used to thin the foreground region such that its extent and connectivity is preserved. Preserving extent means preserving the endpoints of a structure whereas connectivity can refer to either 4-connected or 8-connected. Thinning is mostly used for producing skeletons which serve as image descriptors, and for reducing the output of the edge detectors to a one-pixel thickness, etc.

There are various algorithms to implement the thinning operation such as

Zhang Suen fast parallel thinning algorithm
Non-max Suppression in Canny Edge Detector
Guo and Hall’s two sub-iteration parallel Thinning algorithm
Iterative algorithms using morphological operations such as hit-or-miss, opening and erosion, etc

In this blog, we will only discuss the last algorithm, rest we will discuss in the following blogs. So, let’s get started.

In this, we can implement thinning either using erosion and opening operations or by using hit-or-miss operation. Let’s first discuss thinning using erosion and opening. This can be expressed as the union of skeleton subsets where each subset is given by the following expression (A-Binary image and B-structuring element)

Here, n indicates the number of iterations of erosion. N is the last iterative step before A erodes to the empty set (stopping condition). Now, let’s discuss how to implement this using OpenCV-Python.

import cv2
import numpy as np

# Create an image with text on it
img = np.zeros((100,400),dtype='uint8')
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(img,'TheAILearner',(5,70), font, 2,(255),5,cv2.LINE_AA)
img1 = img.copy()

# Structuring Element
kernel = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))
# Create an empty output image to hold values
thin = np.zeros(img.shape,dtype='uint8')

# Loop until erosion leads to an empty set
while (cv2.countNonZero(img1)!=0):
    # Erosion
    erode = cv2.erode(img1,kernel)
    # Opening on eroded image
    opening = cv2.morphologyEx(erode,cv2.MORPH_OPEN,kernel)
    # Subtract these two
    subset = erode - opening
    # Union of all previous sets
    thin = cv2.bitwise_or(subset,thin)
    # Set the eroded image for next iteration
    img1 = erode.copy()
    
cv2.imshow('original',img)
cv2.imshow('thinned',thin)
cv2.waitKey(0)

import cv2

import numpy as np

# Create an image with text on it

img = np.zeros((100,400),dtype='uint8')

font = cv2.FONT_HERSHEY_SIMPLEX

cv2.putText(img,'TheAILearner',(5,70), font, 2,(255),5,cv2.LINE_AA)

img1 = img.copy()

# Structuring Element

kernel = cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))

# Create an empty output image to hold values

thin = np.zeros(img.shape,dtype='uint8')

# Loop until erosion leads to an empty set

while (cv2.countNonZero(img1)!=0):

# Erosion

erode = cv2.erode(img1,kernel)

# Opening on eroded image

opening = cv2.morphologyEx(erode,cv2.MORPH_OPEN,kernel)

# Subtract these two

subset = erode - opening

# Union of all previous sets

thin = cv2.bitwise_or(subset,thin)

# Set the eroded image for next iteration

img1 = erode.copy()

cv2.imshow('original',img)

cv2.imshow('thinned',thin)

cv2.waitKey(0)

Now, let’s discuss thinning using hit-or-miss transform. Thinning of set A by SE B can be expressed in terms of hit-or-miss transform as

This means we remove all those pixels whose neighborhood exactly matches the pixels in the SE. Instead of applying this with a single structuring element, it is a common practice to implement it using a sequence of SE so as to produce symmetric results. This operation is mostly applied iteratively until no further changes occur.

Thickening

Thickening is the dual of thinning and thus is equivalent to applying the thinning operation on the background or on the complement of the set A.

In the next blog, we will discuss the remaining thinning algorithms in detail. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Hit-or-Miss Transform

Opening and Closing

Closing

This is the just the reverse of Opening i.e Dilation followed by Erosion. Because this closes the holes/gaps present in the object while keeping the initial object size the same. That’s why the name Closing. Now, let’s formulate this in terms of a set operation.

Actual implementation involves rotating the SE by 180 degrees before performing dilation and erosion. But since our SE is mostly symmetric, we usually don’t care. Similar to the opening, this operator is also idempotent. Unlike opening, this fuses narrow breaks or bridges between the objects. Generally, good for removing pepper noise but not salt noise.

Now, let’s discuss how to implement these using OpenCV-Python. For Opening, one way is to first apply erosion and then dilation using the builtin functions we discussed earlier. Similarly, for closing also. Fortunately, OpenCV provides another function that directly implements these operations as shown below.

cv2.morphologyEx(src, op, kernel[, anchor[, iterations[, borderType[, borderValue]]]])

1	cv2.morphologyEx(src, op, kernel[, anchor[, iterations[, borderType[, borderValue]]]])

Here, src is the input image with any number of channels( all will be processed independently) and the kernel is the structuring element whose origin is defined by the anchor (default (-1,-1)). Don’t know why the iterations argument is given because the opening and closing are idempotent operators. You can create the SE using cv2.getStructuringElement() or simply using numpy. It is sometimes useful to pad the image to account for the boundary pixels or if the image is of non-regular shape and this can be done using the “borderType” and “borderValue” arguments. The “op” argument specifies which type of morphological operation to apply. Following are the types available.

MORPH_OPEN – an opening operation
MORPH_CLOSE – a closing operation
MORPH_GRADIENT – a morphological gradient
MORPH_TOPHAT – “top hat”
MORPH_BLACKHAT – “black hat”

Below is an example where we open and close the image with the rectangular SE.

# Define the structuring element
kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))
# Apply the opening operation
opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)
# Apply the closing operation
closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)

# Define the structuring element

kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))

# Apply the opening operation

opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)

# Apply the closing operation

closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)

In the next blog, we will discuss other morphological operators like morphological gradient, top hat, etc. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.