更多形态学变换

目录

• 目标
• 理论
  • 开运算
  • 闭运算
  • 形态梯度
  • 顶帽
  • 黑帽
• 代码
• 解释
• 结果

上一篇教程： 腐蚀和膨胀
下一篇教程： 击中-击不中

原作者	Ana Huamán
兼容性	OpenCV >= 3.0

目标

在本教程中，您将学习如何

• 使用 OpenCV 函数 cv::morphologyEx 应用形态学变换，例如
  • 开运算
  • 闭运算
  • 形态梯度
  • 顶帽
  • 黑帽

理论

注意

下面的解释来自 Bradski 和 Kaehler 合著的学习 OpenCV 一书。

在上一篇教程中，我们介绍了两种基本的形态学运算：

• 腐蚀
• 膨胀

基于这两种运算，我们可以对图像进行更复杂的变换。这里我们简要讨论 OpenCV 提供的 5 种运算：

开运算

• 它是先对图像进行腐蚀，然后进行膨胀得到的。

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

• 用于去除小物体（假设物体在黑暗的前景中是明亮的）。
• 例如，查看下面的示例。左图是原图，右图是在应用开运算后的结果。我们可以观察到，小点消失了。

闭运算

• 它是先对图像进行膨胀，然后进行腐蚀得到的。

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

• 用于去除小孔（暗区）。

形态梯度

• 它是图像膨胀和腐蚀之间的差值。

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

• 它可用于查找物体的轮廓，如下所示

顶帽

• 它是输入图像与其开运算之间的差值。

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

黑帽

• 它是闭运算与其输入图像之间的差值。

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

代码

C++

本教程的代码如下所示。您也可以从此处下载：此处

 
#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 ); // 创建窗口
 
createTrackbar("运算符:\n 0: 开运算 - 1: 闭运算 \n 2: 梯度 - 3: 顶帽 \n 4: 黑帽", window_name, &morph_operator, max_operator, Morphology_Operations );
 
createTrackbar( "元素:\n 0: 矩形 - 1: 十字 - 2: 椭圆", window_name,
&morph_elem, max_elem,
Morphology_Operations );
 
createTrackbar( "核大小:\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* )
{
  // 因为 MORPH_X : 2,3,4,5 和 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

本教程的代码如下所示。您也可以从此处下载：此处

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 {
    私有静态最终 String[] MORPH_OP = { "开运算", "闭运算", "形态梯度", "顶帽", "黑帽" };
    私有静态最终 int[] MORPH_OP_TYPE = { Imgproc.MORPH_OPEN, Imgproc.MORPH_CLOSE,
Imgproc.MORPH_GRADIENT, Imgproc.MORPH_TOPHAT, Imgproc.MORPH_BLACKHAT };
    私有静态最终 String[] ELEMENT_TYPE = { "矩形", "十字形", "椭圆形" };
    私有静态最终 int MAX_KERNEL_SIZE = 21;
    私有 Mat matImgSrc;
    私有 Mat matImgDst = new Mat();
    私有 int morphOpType = Imgproc.MORPH_OPEN;
    私有 int elementType = Imgproc.CV_SHAPE_RECT;
    私有 int kernelSize = 0;
    私有 JFrame frame;
    私有 JLabel imgLabel;
 
    公共 MorphologyDemo2(String[] args) {
String imagePath = args.length > 0 ? args[0] : "../data/LinuxLogo.jpg";
matImgSrc = Imgcodecs.imread(imagePath);
        如果 (matImgSrc.empty()) {
System.out.println("空图像: " + imagePath);
System.exit(0);
        }
 
        // 创建并设置窗口。
frame = new JFrame("形态变换演示");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 设置内容窗格。
Image img = HighGui.toBufferedImage(matImgSrc);
addComponentsToPane(frame.getContentPane(), img);
        // 使用内容窗格的默认BorderLayout。无需
        // setLayout(new BorderLayout());
        // 显示窗口。
frame.pack();
frame.setVisible(true);
    }
 
    私有 void addComponentsToPane(Container pane, Image img) {
        如果 (!(pane.getLayout() instanceof BorderLayout)) {
pane.add(new JLabel("容器未使用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
            公共 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
            公共 void actionPerformed(ActionEvent e) {
@SuppressWarnings("unchecked")
JComboBox<String> cb = (JComboBox<String>)e.getSource();
如果 (cb.getSelectedIndex() == 0) {
elementType = Imgproc.CV_SHAPE_RECT;
} 否则如果 (cb.getSelectedIndex() == 1) {
elementType = Imgproc.CV_SHAPE_CROSS;
} 否则如果 (cb.getSelectedIndex() == 2) {
elementType = Imgproc.CV_SHAPE_ELLIPSE;
                }
update();
            }
        });
sliderPanel.add(elementTypeBox);
 
sliderPanel.add(new JLabel("核大小: 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
            公共 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);
    }
 
    私有 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();
    }
 
    公共 静态 void main(String[] args) {
        // 加载原生OpenCV库
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
 
        // 为事件调度线程安排一个作业
        // 创建和显示此应用程序的GUI。
javax.swing.SwingUtilities.invokeLater(new Runnable() {
@Override
            公共 void run() {
                new MorphologyDemo2(args);
            }
        });
    }
}

Python

本教程的代码如下所示。您也可以在这里下载它 这里

从 __future__ 导入 print_function
导入 cv2 为 cv
导入 numpy 为 np
导入 argparse
 
morph_size = 0
max_operator = 4
max_elem = 2
max_kernel_size = 21
title_trackbar_operator_type = "运算符:\n 0: 开运算 - 1: 闭运算 \n 2: 形态梯度 - 3: 顶帽 \n 4: 黑帽"
title_trackbar_element_type = "元素:\n 0: 矩形 - 1: 十字形 - 2: 椭圆形"
title_trackbar_kernel_size = "核大小:\n 2n + 1"
title_window = "形态变换演示"
morph_op_dic = {0: cv.MORPH_OPEN, 1: cv.MORPH_CLOSE, 2: cv.MORPH_GRADIENT, 3: cv.MORPH_TOPHAT, 4: cv.MORPH_BLACKHAT}
 
定义 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)
    如果 val_type == 0
morph_elem = cv.MORPH_RECT
    否则如果 val_type == 1
morph_elem = cv.MORPH_CROSS
    否则如果 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="形态变换教程代码。")
parser.add_argument("--input", help="输入图像路径。", default="LinuxLogo.jpg")
args = parser.parse_args()
 
src = cv.imread(cv.samples.findFile(args.input))
如果 src 为 空
print('无法打开或找到图像: ', 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()

说明

1. 让我们检查C++程序的总体结构
   • 加载图像
   • 创建一个窗口来显示形态学运算的结果
   • 创建三个轨迹条供用户输入参数
     • 第一个轨迹条 **算子** 返回要使用的形态学运算类型 (**morph_operator**)。

         createTrackbar("算子:\n 0: 开运算 - 1: 闭运算 \n 2: 梯度 - 3: 顶帽 \n 4: 黑帽", window_name, &morph_operator, max_operator, Morphology_Operations );

     • 第二个轨迹条 **元素** 返回 **morph_elem**，它指示我们的内核是什么样的结构

         createTrackbar( "元素:\n 0: 矩形 - 1: 十字形 - 2: 椭圆形", window_name,
       &morph_elem, max_elem,
       Morphology_Operations );

     • 最后一个轨迹条 **内核大小** 返回要使用的内核大小 (**morph_size**)

         createTrackbar( "内核大小:\n 2n +1", window_name,
       &morph_size, max_kernel_size,
       Morphology_Operations );

   • 每次我们移动任何滑块时，用户的函数 **Morphology_Operations** 将被调用以执行新的形态学运算，它将根据当前轨迹条的值更新输出图像。

      
     void Morphology_Operations( int, void* )
     {
       // 因为 MORPH_X : 2,3,4,5 和 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 );
     }

     我们可以观察到执行形态学变换的关键函数是 cv::morphologyEx。在这个例子中，我们使用四个参数（其余参数使用默认值）

     • **src**: 源（输入）图像
     • **dst**: 输出图像

     • **operation**: 要执行的形态学变换类型。请注意，我们有5个备选方案

       • 开运算: MORPH_OPEN : 2
       • 闭运算: MORPH_CLOSE: 3
       • 梯度: MORPH_GRADIENT: 4
       • 顶帽: MORPH_TOPHAT: 5
       • 黑帽: MORPH_BLACKHAT: 6

       正如你所看到的，这些值范围是 <2-6>，这就是为什么我们将轨迹条输入的值加上 (+2) 的原因

         int operation = morph_operator + 2;

     • **element**: 要使用的内核。我们使用函数 cv::getStructuringElement 来定义我们自己的结构。

结果

• 编译上述代码后，我们可以执行它，并将图像路径作为参数提供。使用图像：**baboon.png** 的结果

• 这里有两张显示窗口的快照。第一张图片显示使用十字形内核的 **开运算** 算子后的输出。第二张图片（右侧）显示使用椭圆形内核的 **黑帽** 算子的结果。