More Morphology Transformations

Table of Contents

• Goal
• Theory
  • Opening
  • Closing
  • Morphological Gradient
  • Top Hat
  • Black Hat
• Code
• Explanation
• Results

Prev Tutorial: Eroding and Dilating
Next Tutorial: Hit-or-Miss

Original author	Ana Huamán
Compatibility	OpenCV >= 3.0

Goal

In this tutorial you will learn how to:

• Use the OpenCV function cv::morphologyEx to apply Morphological Transformation such as:
  • Opening
  • Closing
  • Morphological Gradient
  • Top Hat
  • Black Hat

Theory

Note

The explanation below belongs to the book Learning OpenCV by Bradski and Kaehler.

In the previous tutorial we covered two basic Morphology operations:

• Erosion
• Dilation.

Based on these two we can effectuate more sophisticated transformations to our images. Here we discuss briefly 5 operations offered by OpenCV:

Opening

• It is obtained by the erosion of an image followed by a dilation.

  \[dst = open( src, element) = dilate( erode( src, element ) )\]

• Useful for removing small objects (it is assumed that the objects are bright on a dark foreground)
• For instance, check out the example below. The image at the left is the original and the image at the right is the result after applying the opening transformation. We can observe that the small dots have disappeared.

Closing

• It is obtained by the dilation of an image followed by an erosion.

  \[dst = close( src, element ) = erode( dilate( src, element ) )\]

• Useful to remove small holes (dark regions).

Morphological Gradient

• It is the difference between the dilation and the erosion of an image.

  \[dst = morph_{grad}( src, element ) = dilate( src, element ) - erode( src, element )\]

• It is useful for finding the outline of an object as can be seen below:

Top Hat

• It is the difference between an input image and its opening.

  \[dst = tophat( src, element ) = src - open( src, element )\]

Black Hat

• It is the difference between the closing and its input image

  \[dst = blackhat( src, element ) = close( src, element ) - src\]

Code

C++

This tutorial's code is shown below. You can also download it here

 
#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui.hpp"
#include <iostream>
 
using namespace cv;
 
Mat src, dst;
 
int morph_elem = 0;
int morph_size = 0;
int morph_operator = 0;
int const max_operator = 4;
int const max_elem = 2;
int const max_kernel_size = 21;
 
const char* window_name = "Morphology Transformations Demo";
 
 
void Morphology_Operations( int, void* );
 
int main( int argc, char** argv )
{
 CommandLineParser parser( argc, argv, "{@input | baboon.jpg | input image}" );
 src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR );
 if (src.empty())
 {
 std::cout << "Could not open or find the image!\n" << std::endl;
 std::cout << "Usage: " << argv[0] << " <Input image>" << std::endl;
 return EXIT_FAILURE;
 }
 
 namedWindow( window_name, WINDOW_AUTOSIZE ); // Create window
 
 createTrackbar("Operator:\n 0: Opening - 1: Closing \n 2: Gradient - 3: Top Hat \n 4: Black Hat", window_name, &morph_operator, max_operator, Morphology_Operations );
 
 createTrackbar( "Element:\n 0: Rect - 1: Cross - 2: Ellipse", window_name,
 &morph_elem, max_elem,
 Morphology_Operations );
 
 createTrackbar( "Kernel size:\n 2n +1", window_name,
 &morph_size, max_kernel_size,
 Morphology_Operations );
 
 Morphology_Operations( 0, 0 );
 
 waitKey(0);
 return 0;
}
 
 
void Morphology_Operations( int, void* )
{
 // Since MORPH_X : 2,3,4,5 and 6
 int operation = morph_operator + 2;
 
 Mat element = getStructuringElement( morph_elem, Size( 2*morph_size + 1, 2*morph_size+1 ), Point( morph_size, morph_size ) );
 
 morphologyEx( src, dst, operation, element );
 imshow( window_name, dst );
}

Java

This tutorial's code is shown below. You can also download it here

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.BoxLayout;
import javax.swing.ImageIcon;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
 
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Size;
import org.opencv.highgui.HighGui;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
 
public class MorphologyDemo2 {
 private static final String[] MORPH_OP = { "Opening", "Closing", "Gradient", "Top Hat", "Black Hat" };
 private static final int[] MORPH_OP_TYPE = { Imgproc.MORPH_OPEN, Imgproc.MORPH_CLOSE,
 Imgproc.MORPH_GRADIENT, Imgproc.MORPH_TOPHAT, Imgproc.MORPH_BLACKHAT };
 private static final String[] ELEMENT_TYPE = { "Rectangle", "Cross", "Ellipse" };
 private static final int MAX_KERNEL_SIZE = 21;
 private Mat matImgSrc;
 private Mat matImgDst = new Mat();
 private int morphOpType = Imgproc.MORPH_OPEN;
 private int elementType = Imgproc.CV_SHAPE_RECT;
 private int kernelSize = 0;
 private JFrame frame;
 private JLabel imgLabel;
 
 public MorphologyDemo2(String[] args) {
 String imagePath = args.length > 0 ? args[0] : "../data/LinuxLogo.jpg";
 matImgSrc = Imgcodecs.imread(imagePath);
 if (matImgSrc.empty()) {
 System.out.println("Empty image: " + imagePath);
 System.exit(0);
 }
 
 // Create and set up the window.
 frame = new JFrame("Morphology Transformations demo");
 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 // Set up the content pane.
 Image img = HighGui.toBufferedImage(matImgSrc);
 addComponentsToPane(frame.getContentPane(), img);
 // Use the content pane's default BorderLayout. No need for
 // setLayout(new BorderLayout());
 // Display the window.
 frame.pack();
 frame.setVisible(true);
 }
 
 private void addComponentsToPane(Container pane, Image img) {
 if (!(pane.getLayout() instanceof BorderLayout)) {
 pane.add(new JLabel("Container doesn't use BorderLayout!"));
 return;
 }
 
 JPanel sliderPanel = new JPanel();
 sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
 
 JComboBox<String> morphOpBox = new JComboBox<>(MORPH_OP);
 morphOpBox.addActionListener(new ActionListener() {
 @Override
 public void actionPerformed(ActionEvent e) {
 @SuppressWarnings("unchecked")
 JComboBox<String> cb = (JComboBox<String>)e.getSource();
 morphOpType = MORPH_OP_TYPE[cb.getSelectedIndex()];
 update();
 }
 });
 sliderPanel.add(morphOpBox);
 
 JComboBox<String> elementTypeBox = new JComboBox<>(ELEMENT_TYPE);
 elementTypeBox.addActionListener(new ActionListener() {
 @Override
 public void actionPerformed(ActionEvent e) {
 @SuppressWarnings("unchecked")
 JComboBox<String> cb = (JComboBox<String>)e.getSource();
 if (cb.getSelectedIndex() == 0) {
 elementType = Imgproc.CV_SHAPE_RECT;
 } else if (cb.getSelectedIndex() == 1) {
 elementType = Imgproc.CV_SHAPE_CROSS;
 } else if (cb.getSelectedIndex() == 2) {
 elementType = Imgproc.CV_SHAPE_ELLIPSE;
 }
 update();
 }
 });
 sliderPanel.add(elementTypeBox);
 
 sliderPanel.add(new JLabel("Kernel size: 2n + 1"));
 JSlider slider = new JSlider(0, MAX_KERNEL_SIZE, 0);
 slider.setMajorTickSpacing(5);
 slider.setMinorTickSpacing(5);
 slider.setPaintTicks(true);
 slider.setPaintLabels(true);
 slider.addChangeListener(new ChangeListener() {
 @Override
 public void stateChanged(ChangeEvent e) {
 JSlider source = (JSlider) e.getSource();
 kernelSize = source.getValue();
 update();
 }
 });
 sliderPanel.add(slider);
 
 pane.add(sliderPanel, BorderLayout.PAGE_START);
 imgLabel = new JLabel(new ImageIcon(img));
 pane.add(imgLabel, BorderLayout.CENTER);
 }
 
 private void update() {
 Mat element = Imgproc.getStructuringElement(elementType, new Size(2 * kernelSize + 1, 2 * kernelSize + 1),
 new Point(kernelSize, kernelSize));
 
 Imgproc.morphologyEx(matImgSrc, matImgDst, morphOpType, element);
 Image img = HighGui.toBufferedImage(matImgDst);
 imgLabel.setIcon(new ImageIcon(img));
 frame.repaint();
 }
 
 public static void main(String[] args) {
 // Load the native OpenCV library
 System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
 
 // Schedule a job for the event dispatch thread:
 // creating and showing this application's GUI.
 javax.swing.SwingUtilities.invokeLater(new Runnable() {
 @Override
 public void run() {
 new MorphologyDemo2(args);
 }
 });
 }
}

Python

This tutorial's code is shown below. You can also download it here

from __future__ import print_function
import cv2 as cv
import numpy as np
import argparse
 
morph_size = 0
max_operator = 4
max_elem = 2
max_kernel_size = 21
title_trackbar_operator_type = 'Operator:\n 0: Opening - 1: Closing \n 2: Gradient - 3: Top Hat \n 4: Black Hat'
title_trackbar_element_type = 'Element:\n 0: Rect - 1: Cross - 2: Ellipse'
title_trackbar_kernel_size = 'Kernel size:\n 2n + 1'
title_window = 'Morphology Transformations Demo'
morph_op_dic = {0: cv.MORPH_OPEN, 1: cv.MORPH_CLOSE, 2: cv.MORPH_GRADIENT, 3: cv.MORPH_TOPHAT, 4: cv.MORPH_BLACKHAT}
 
def morphology_operations(val):
 morph_operator = cv.getTrackbarPos(title_trackbar_operator_type, title_window)
 morph_size = cv.getTrackbarPos(title_trackbar_kernel_size, title_window)
 morph_elem = 0
 val_type = cv.getTrackbarPos(title_trackbar_element_type, title_window)
 if val_type == 0:
 morph_elem = cv.MORPH_RECT
 elif val_type == 1:
 morph_elem = cv.MORPH_CROSS
 elif val_type == 2:
 morph_elem = cv.MORPH_ELLIPSE
 
 element = cv.getStructuringElement(morph_elem, (2*morph_size + 1, 2*morph_size+1), (morph_size, morph_size))
 operation = morph_op_dic[morph_operator]
 dst = cv.morphologyEx(src, operation, element)
 cv.imshow(title_window, dst)
 
parser = argparse.ArgumentParser(description='Code for More Morphology Transformations tutorial.')
parser.add_argument('--input', help='Path to input image.', default='LinuxLogo.jpg')
args = parser.parse_args()
 
src = cv.imread(cv.samples.findFile(args.input))
if src is None:
 print('Could not open or find the image: ', args.input)
 exit(0)
 
cv.namedWindow(title_window)
cv.createTrackbar(title_trackbar_operator_type, title_window , 0, max_operator, morphology_operations)
cv.createTrackbar(title_trackbar_element_type, title_window , 0, max_elem, morphology_operations)
cv.createTrackbar(title_trackbar_kernel_size, title_window , 0, max_kernel_size, morphology_operations)
 
morphology_operations(0)
cv.waitKey()

Explanation

1. Let's check the general structure of the C++ program:
   • Load an image
   • Create a window to display results of the Morphological operations
   • Create three Trackbars for the user to enter parameters:
     • The first trackbar Operator returns the kind of morphology operation to use (morph_operator).

        
        createTrackbar("Operator:\n 0: Opening - 1: Closing \n 2: Gradient - 3: Top Hat \n 4: Black Hat", window_name, &morph_operator, max_operator, Morphology_Operations );

     • The second trackbar Element returns morph_elem, which indicates what kind of structure our kernel is:

        
        createTrackbar( "Element:\n 0: Rect - 1: Cross - 2: Ellipse", window_name,
        &morph_elem, max_elem,
        Morphology_Operations );

     • The final trackbar Kernel Size returns the size of the kernel to be used (morph_size)

        
        createTrackbar( "Kernel size:\n 2n +1", window_name,
        &morph_size, max_kernel_size,
        Morphology_Operations );

   • Every time we move any slider, the user's function Morphology_Operations will be called to effectuate a new morphology operation and it will update the output image based on the current trackbar values.

      
     void Morphology_Operations( int, void* )
     {
      // Since MORPH_X : 2,3,4,5 and 6
      int operation = morph_operator + 2;
      
      Mat element = getStructuringElement( morph_elem, Size( 2*morph_size + 1, 2*morph_size+1 ), Point( morph_size, morph_size ) );
      
      morphologyEx( src, dst, operation, element );
      imshow( window_name, dst );
     }

     We can observe that the key function to perform the morphology transformations is cv::morphologyEx . In this example we use four arguments (leaving the rest as defaults):

     • src : Source (input) image
     • dst: Output image

     • operation: The kind of morphology transformation to be performed. Note that we have 5 alternatives:

       • Opening: MORPH_OPEN : 2
       • Closing: MORPH_CLOSE: 3
       • Gradient: MORPH_GRADIENT: 4
       • Top Hat: MORPH_TOPHAT: 5
       • Black Hat: MORPH_BLACKHAT: 6

       As you can see the values range from <2-6>, that is why we add (+2) to the values entered by the Trackbar:

        int operation = morph_operator + 2;

     • element: The kernel to be used. We use the function cv::getStructuringElement to define our own structure.

Results

• After compiling the code above we can execute it giving an image path as an argument. Results using the image: baboon.png:

• And here are two snapshots of the display window. The first picture shows the output after using the operator Opening with a cross kernel. The second picture (right side, shows the result of using a Blackhat operator with an ellipse kernel.