图像腐蚀和膨胀

目录

• 目标
• 形态学操作
  • 膨胀
  • 腐蚀
• 代码
• 原理解释
  • 腐蚀函数 (CPP)
  • 膨胀函数 (CPP)
  • 更新图像 (Java)
  • 腐蚀方法 (Java)
  • 膨胀函数 (Java)
  • 腐蚀函数 (Python)
  • 膨胀函数 (Python)
• 结果

上一个教程： 图像平滑
下一个教程： 更多形态学变换

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

目标

在本教程中，你将学习如何：

• 应用两个非常常见的形态学运算符：腐蚀和膨胀。为此，您将使用以下 OpenCV 函数
  • cv::erode
  • cv::dilate

注意

下面的解释摘自 Bradski 和 Kaehler 的书 Learning OpenCV。

形态学操作

• 简而言之：一组基于形状处理图像的操作。形态学操作将一个结构元素应用于输入图像并生成输出图像。
• 最基本的形态学操作是：腐蚀和膨胀。它们有广泛的用途，例如：
  • 去除噪声
  • 图像中单个元素的隔离和不同元素的连接。
  • 查找图像中的强度凸起或空洞
• 我们将简要解释膨胀和腐蚀，以下图为例

膨胀

• 此操作包括将图像 \(A\) 与某个内核 ( \(B\)) 进行卷积，该内核可以具有任何形状或大小，通常是正方形或圆形。
• 内核 \(B\) 有一个定义的锚点，通常是内核的中心。
• 当内核 \(B\) 在图像上扫描时，我们计算被 \(B\) 覆盖的最大像素值，并用该最大值替换锚点位置的图像像素。正如您所推断的，这种最大化操作会导致图像中的明亮区域“增长”（因此得名膨胀）。
• 膨胀操作是： \(\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\)
• 以上图为例。应用膨胀我们可以得到

• 字母的明亮区域在背景的黑色区域周围膨胀。

腐蚀

• 此操作是膨胀的姐妹操作。它计算给定内核区域上的局部最小值。
• 当内核 \(B\) 在图像上扫描时，我们计算被 \(B\) 覆盖的最小像素值，并用该最小值替换锚点下的图像像素。
• 腐蚀操作是： \(\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\)
• 与膨胀的例子类似，我们可以将腐蚀运算符应用于原始图像（如上所示）。您可以在下面的结果中看到，图像的明亮区域变细，而黑暗区域变大。

代码

C++

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

 
#include "opencv2/imgproc.hpp"
#include "opencv2/highgui.hpp"
#include <iostream>
 
using namespace cv;
using namespace std;
 
Mat src, erosion_dst, dilation_dst;
 
int erosion_elem = 0;
int erosion_size = 0;
int dilation_elem = 0;
int dilation_size = 0;
int const max_elem = 3;
int const max_kernel_size = 21;
 
void Erosion( int, void* );
void Dilation( int, void* );
 
 
int main( int argc, char** argv )
{
  CommandLineParser parser( argc, argv, "{@input | LinuxLogo.jpg | input image}" );
src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR );
  if( src.empty() )
  {
cout << "无法打开或找到图像！\n" << endl;
cout << "用法: " << argv[0] << " <输入图像>" << endl;
    return -1;
  }
 
namedWindow( "Erosion Demo", WINDOW_AUTOSIZE );
namedWindow( "Dilation Demo", WINDOW_AUTOSIZE );
moveWindow( "Dilation Demo", src.cols, 0 );
 
createTrackbar( "Element:\n 0: Rect \n 1: Cross \n 2: Ellipse \n 3: Diamond", "Erosion Demo",
&erosion_elem, max_elem,
Erosion );
 
createTrackbar( "Kernel size:\n 2n +1", "Erosion Demo",
&erosion_size, max_kernel_size,
Erosion );
 
createTrackbar( "Element:\n 0: Rect \n 1: Cross \n 2: Ellipse \n 3: Diamond", "Dilation Demo",
&dilation_elem, max_elem,
Dilation );
 
createTrackbar( "Kernel size:\n 2n +1", "Dilation Demo",
&dilation_size, max_kernel_size,
Dilation );
 
Erosion( 0, 0 );
Dilation( 0, 0 );
 
waitKey(0);
  return 0;
}
 
 
void Erosion( int, void* )
{
  int erosion_type = 0;
  if( erosion_elem == 0 ){ erosion_type = MORPH_RECT; }
  else if( erosion_elem == 1 ){ erosion_type = MORPH_CROSS; }
  else if( erosion_elem == 2) { erosion_type = MORPH_ELLIPSE; }
  else if( erosion_elem == 3) { erosion_type = MORPH_DIAMOND; }
 
  Mat element = getStructuringElement( erosion_type,
                       Size( 2*erosion_size + 1, 2*erosion_size+1 ),
                       Point( erosion_size, erosion_size ) );
 
  erode( src, erosion_dst, element );
  imshow( "Erosion Demo", erosion_dst );
}
 
 
void Dilation( int, void* )
{
  int dilation_type = 0;
  if( dilation_elem == 0 ){ dilation_type = MORPH_RECT; }
  else if( dilation_elem == 1 ){ dilation_type = MORPH_CROSS; }
  else if( dilation_elem == 2) { dilation_type = MORPH_ELLIPSE; }
  else if( dilation_elem == 3) { dilation_type = MORPH_DIAMOND; }
 
  Mat element = getStructuringElement( dilation_type,
                       Size( 2*dilation_size + 1, 2*dilation_size+1 ),
                       Point( dilation_size, dilation_size ) );
 
  dilate( src, dilation_dst, element );
  imshow( "Dilation Demo", dilation_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 MorphologyDemo1 {
    private static final String[] ELEMENT_TYPE = { "Rectangle", "Cross", "Ellipse", "Diamond" };
    private static final String[] MORPH_OP = { "Erosion", "Dilatation" };
    private static final int MAX_KERNEL_SIZE = 21;
    private Mat matImgSrc;
    private Mat matImgDst = new Mat();
    private int elementType = Imgproc.MORPH_RECT;
    private int kernelSize = 0;
    private boolean doErosion = true;
    private JFrame frame;
    private JLabel imgLabel;
 
    public MorphologyDemo1(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);
        }
 
        // 创建并设置窗口。
frame = new JFrame("Erosion and dilatation demo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 设置内容窗格。
Image img = HighGui.toBufferedImage(matImgSrc);
addComponentsToPane(frame.getContentPane(), img);
        // 使用内容窗格的默认 BorderLayout。无需
        // setLayout(new BorderLayout());
        // 显示窗口。
frame.pack();
frame.setVisible(true);
    }
 
    private void addComponentsToPane(Container pane, Image img) {
        if (!(pane.getLayout() instanceof BorderLayout)) {
pane.add(new JLabel("容器未使用 BorderLayout！"));
            return;
        }
 
JPanel sliderPanel = new JPanel();
sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
 
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.MORPH_RECT;
} else if (cb.getSelectedIndex() == 1) {
elementType = Imgproc.MORPH_CROSS;
} else if (cb.getSelectedIndex() == 2) {
elementType = Imgproc.MORPH_ELLIPSE;
} else if (cb.getSelectedIndex() == 3) {
elementType = Imgproc.MORPH_DIAMOND;
                }
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);
 
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();
doErosion = cb.getSelectedIndex() == 0;
update();
            }
        });
sliderPanel.add(morphOpBox);
 
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));
 
        if (doErosion) {
Imgproc.erode(matImgSrc, matImgDst, element);
} else {
Imgproc.dilate(matImgSrc, matImgDst, element);
        }
Image img = HighGui.toBufferedImage(matImgDst);
imgLabel.setIcon(new ImageIcon(img));
frame.repaint();
    }
 
    public static void main(String[] args) {
        // 加载本地 OpenCV 库
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
 
        // 安排事件调度线程上的作业
        // 创建并显示此应用程序的 GUI。
javax.swing.SwingUtilities.invokeLater(new Runnable() {
@Override
            public void run() {
                new MorphologyDemo1(args);
            }
        });
    }
}

Python

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

from __future__ import print_function
import cv2 as cv
import numpy as np
import argparse
 
src = None
erosion_size = 0
max_elem = 3
max_kernel_size = 21
title_trackbar_element_shape = 'Element:\n 0: Rect \n 1: Cross \n 2: Ellipse \n 3: Diamond'
title_trackbar_kernel_size = 'Kernel size:\n 2n +1'
title_erosion_window = 'Erosion Demo'
title_dilation_window = 'Dilation Demo'
 
 
 
def main(image)
    global src
src = cv.imread(cv.samples.findFile(image))
    if src is None
print('Could not open or find the image: ', image)
exit(0)
 
    cv.namedWindow(title_erosion_window)
    cv.createTrackbar(title_trackbar_element_shape, title_erosion_window, 0, max_elem, erosion)
    cv.createTrackbar(title_trackbar_kernel_size, title_erosion_window, 0, max_kernel_size, erosion)
 
    cv.namedWindow(title_dilation_window)
    cv.createTrackbar(title_trackbar_element_shape, title_dilation_window, 0, max_elem, dilatation)
    cv.createTrackbar(title_trackbar_kernel_size, title_dilation_window, 0, max_kernel_size, dilatation)
 
erosion(0)
dilatation(0)
    cv.waitKey()
 
 
# 可选的形态学形状值映射
def morph_shape(val)
    if val == 0
        return cv.MORPH_RECT
    elif val == 1
        return cv.MORPH_CROSS
    elif val == 2
        return cv.MORPH_ELLIPSE
    elif val == 3
        return cv.MORPH_DIAMOND
 
 
 
def erosion(val)
erosion_size = cv.getTrackbarPos(title_trackbar_kernel_size, title_erosion_window)
erosion_shape = morph_shape(cv.getTrackbarPos(title_trackbar_element_shape, title_erosion_window))
 
    
element = cv.getStructuringElement(erosion_shape, (2 * erosion_size + 1, 2 * erosion_size + 1),
(erosion_size, erosion_size))
    
erosion_dst = cv.erode(src, element)
    cv.imshow(title_erosion_window, erosion_dst)
 
 
 
 
def dilatation(val)
dilatation_size = cv.getTrackbarPos(title_trackbar_kernel_size, title_dilation_window)
dilation_shape = morph_shape(cv.getTrackbarPos(title_trackbar_element_shape, title_dilation_window))
 
element = cv.getStructuringElement(dilation_shape, (2 * dilatation_size + 1, 2 * dilatation_size + 1),
(dilatation_size, dilatation_size))
dilatation_dst = cv.dilate(src, element)
    cv.imshow(title_dilation_window, dilatation_dst)
 
 
 
if __name__ == "__main__"
parser = argparse.ArgumentParser(description='腐蚀和膨胀教程代码。')
parser.add_argument('--input', help='输入图像的路径。', default='LinuxLogo.jpg')
args = parser.parse_args()
 
    main(args.input)

解释

C++

这里显示的大部分内容都是微不足道的（如果您有任何疑问，请参阅前面章节的教程）。让我们检查一下 C++ 程序的通用结构

 
int main( int argc, char** argv )
{
  CommandLineParser parser( argc, argv, "{@input | LinuxLogo.jpg | input image}" );
src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR );
  if( src.empty() )
  {
cout << "无法打开或找到图像！\n" << endl;
cout << "用法: " << argv[0] << " <输入图像>" << endl;
    return -1;
  }
 
  namedWindow( "Erosion Demo", WINDOW_AUTOSIZE );
  namedWindow( "Dilation Demo", WINDOW_AUTOSIZE );
  moveWindow( "Dilation Demo", src.cols, 0 );
 
  createTrackbar( "Element:\n 0: Rect \n 1: Cross \n 2: Ellipse \n 3: Diamond", "Erosion Demo",
&erosion_elem, max_elem,
Erosion );
 
  createTrackbar( "Kernel size:\n 2n +1", "Erosion Demo",
&erosion_size, max_kernel_size,
Erosion );
 
  createTrackbar( "Element:\n 0: Rect \n 1: Cross \n 2: Ellipse \n 3: Diamond", "Dilation Demo",
&dilation_elem, max_elem,
Dilation );
 
  createTrackbar( "Kernel size:\n 2n +1", "Dilation Demo",
&dilation_size, max_kernel_size,
Dilation );
 
Erosion( 0, 0 );
Dilation( 0, 0 );
 
  waitKey(0);
  return 0;
}

1. 加载图像（可以是 BGR 或灰度图）
2. 创建两个窗口（一个用于膨胀输出，另一个用于腐蚀输出）
3. 为每个操作创建一组两个跟踪条
   • 第一个跟踪条“元素”返回 erosion_elem 或 dilation_elem
   • 第二个跟踪条“内核大小”返回相应操作的 erosion_size 或 dilation_size。
4. 调用腐蚀和膨胀一次以显示初始图像。

每次移动任何滑块时，都会调用用户的函数 Erosion 或 Dilation，它将根据当前的跟踪条值更新输出图像。

让我们分析这两个函数

腐蚀函数 (CPP)

 
void Erosion( int, void* )
{
  int erosion_type = 0;
  if( erosion_elem == 0 ){ erosion_type = MORPH_RECT; }
  else if( erosion_elem == 1 ){ erosion_type = MORPH_CROSS; }
  else if( erosion_elem == 2) { erosion_type = MORPH_ELLIPSE; }
  else if( erosion_elem == 3) { erosion_type = MORPH_DIAMOND; }
 
  Mat element = getStructuringElement( erosion_type,
                       Size( 2*erosion_size + 1, 2*erosion_size+1 ),
                       Point( erosion_size, erosion_size ) );
 
  erode( src, erosion_dst, element );
  imshow( "Erosion Demo", erosion_dst );
}

执行腐蚀操作的函数是 cv::erode 。如我们所见，它接收三个参数

• src：源图像
• erosion_dst：输出图像

• element：这是我们将用于执行操作的内核。如果我们未指定，默认是一个简单的 3x3 矩阵。否则，我们可以指定其形状。为此，我们需要使用函数 cv::getStructuringElement

    Mat element = getStructuringElement( erosion_type,
                         Size( 2*erosion_size + 1, 2*erosion_size+1 ),
                         Point( erosion_size, erosion_size ) );

  我们可以为内核选择以下三种形状中的任何一种

  • 矩形框：MORPH_RECT
  • 十字形：MORPH_CROSS
  • 椭圆形：MORPH_ELLIPSE
  • 菱形：MORPH_DIAMOND

  然后，我们只需指定内核的大小和锚点。如果未指定，则假定其在中心。

就是这样。我们准备好对图像进行腐蚀。

膨胀函数 (CPP)

代码如下所示。如您所见，它与腐蚀的代码片段完全相似。在这里，我们还可以选择定义我们的内核、其锚点以及要使用的操作符的大小。

 
void Dilation( int, void* )
{
  int dilation_type = 0;
  if( dilation_elem == 0 ){ dilation_type = MORPH_RECT; }
  else if( dilation_elem == 1 ){ dilation_type = MORPH_CROSS; }
  else if( dilation_elem == 2) { dilation_type = MORPH_ELLIPSE; }
  else if( dilation_elem == 3) { dilation_type = MORPH_DIAMOND; }
 
  Mat element = getStructuringElement( dilation_type,
                       Size( 2*dilation_size + 1, 2*dilation_size+1 ),
                       Point( dilation_size, dilation_size ) );
 
  dilate( src, dilation_dst, element );
  imshow( "Dilation Demo", dilation_dst );
}

Java

这里显示的大部分内容都是微不足道的（如果您有任何疑问，请参阅前面章节的教程）。但是，让我们检查一下 Java 类的通用结构。Java 类主要有 4 个部分

• 类构造函数，它设置将填充窗口组件的窗口
• addComponentsToPane 方法，它填充窗口
• update 方法，它决定当用户更改任何值时会发生什么
• main 方法，它是程序的入口点

在本教程中，我们将重点关注 addComponentsToPane 和 update 方法。但是，为了完整性，构造函数中遵循的步骤是

1. 加载图像（可以是 BGR 或灰度图）
2. 创建一个窗口
3. 使用 addComponentsToPane 添加各种控制组件
4. 显示窗口

组件通过以下方法添加

    private void addComponentsToPane(Container pane, Image img) {
        if (!(pane.getLayout() instanceof BorderLayout)) {
pane.add(new JLabel("容器未使用 BorderLayout！"));
            return;
        }
 
JPanel sliderPanel = new JPanel();
sliderPanel.setLayout(new BoxLayout(sliderPanel, BoxLayout.PAGE_AXIS));
 
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.MORPH_RECT;
} else if (cb.getSelectedIndex() == 1) {
elementType = Imgproc.MORPH_CROSS;
} else if (cb.getSelectedIndex() == 2) {
elementType = Imgproc.MORPH_ELLIPSE;
} else if (cb.getSelectedIndex() == 3) {
elementType = Imgproc.MORPH_DIAMOND;
                }
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);
 
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();
doErosion = cb.getSelectedIndex() == 0;
update();
            }
        });
sliderPanel.add(morphOpBox);
 
pane.add(sliderPanel, BorderLayout.PAGE_START);
imgLabel = new JLabel(new ImageIcon(img));
pane.add(imgLabel, BorderLayout.CENTER);
    }

简而言之，我们

1. 为滑块创建一个面板
2. 为元素类型创建一个组合框
3. 为内核大小创建一个滑块
4. 为要使用的形态学函数（腐蚀或膨胀）创建一个组合框

添加的动作和状态更改监听器在最后调用 update 方法，该方法根据当前的滑块值更新图像。因此，每次移动任何滑块时，都会触发 update 方法。

更新图像 (Java)

为了更新图像，我们使用了以下实现

private void update() {
Mat element = Imgproc.getStructuringElement(elementType, new Size(2 * kernelSize + 1, 2 * kernelSize + 1),
                new Point(kernelSize, kernelSize));
 
        if (doErosion) {
Imgproc.erode(matImgSrc, matImgDst, element);
} else {
Imgproc.dilate(matImgSrc, matImgDst, element);
        }
Image img = HighGui.toBufferedImage(matImgDst);
imgLabel.setIcon(new ImageIcon(img));
frame.repaint();
    }

换句话说，我们

1. 获取用户选择的结构元素
2. 根据 doErosion 执行腐蚀或膨胀函数
3. 重新加载应用了形态学的图像
4. 重绘框架

让我们分析 erode 和 dilate 方法

腐蚀方法 (Java)

Imgproc.erode(matImgSrc, matImgDst, element);

执行腐蚀操作的函数是 cv::erode 。如我们所见，它接收三个参数

• src：源图像
• erosion_dst：输出图像

• element：这是我们将用于执行操作的内核。为了指定形状，我们需要使用函数 cv::getStructuringElement

  Mat element = Imgproc.getStructuringElement(elementType, new Size(2 * kernelSize + 1, 2 * kernelSize + 1),
                  new Point(kernelSize, kernelSize));

  我们可以为内核选择以下三种形状中的任何一种

  • 矩形框：Imgproc.SHAPE_RECT
  • 十字形：Imgproc.SHAPE_CROSS
  • 椭圆形：Imgproc.SHAPE_ELLIPSE

  除了形状之外，我们还指定内核的大小和锚点。如果未指定锚点，则假定其在中心。

就是这样。我们准备好对图像进行腐蚀。

膨胀函数 (Java)

代码如下所示。如您所见，它与腐蚀的代码片段完全相似。在这里，我们还可以选择定义我们的内核、其锚点以及要使用的操作符的大小。

Imgproc.dilate(matImgSrc, matImgDst, element);

Python

这里显示的大部分内容都是微不足道的（如果您有任何疑问，请参阅前面章节的教程）。让我们检查一下 Python 脚本的通用结构

def main(image)
    global src
src = cv.imread(cv.samples.findFile(image))
    if src is None
print('Could not open or find the image: ', image)
exit(0)
 
    cv.namedWindow(title_erosion_window)
    cv.createTrackbar(title_trackbar_element_shape, title_erosion_window, 0, max_elem, erosion)
    cv.createTrackbar(title_trackbar_kernel_size, title_erosion_window, 0, max_kernel_size, erosion)
 
    cv.namedWindow(title_dilation_window)
    cv.createTrackbar(title_trackbar_element_shape, title_dilation_window, 0, max_elem, dilatation)
    cv.createTrackbar(title_trackbar_kernel_size, title_dilation_window, 0, max_kernel_size, dilatation)
 
erosion(0)
dilatation(0)
    cv.waitKey()

1. 加载图像（可以是 BGR 或灰度图）
2. 创建两个窗口（一个用于腐蚀输出，另一个用于膨胀输出），每个窗口都带有一组跟踪条
   • 第一个跟踪条“元素”返回将映射的形态学类型值（1 = 矩形，2 = 十字形，3 = 椭圆形）
   • 第二个跟踪条“内核大小”返回相应操作的元素大小
3. 调用腐蚀和膨胀一次以显示初始图像

每次移动任何滑块时，都会调用用户的函数 erosion 或 dilation，它将根据当前的跟踪条值更新输出图像。

让我们分析这两个函数

腐蚀函数 (Python)

def erosion(val)
erosion_size = cv.getTrackbarPos(title_trackbar_kernel_size, title_erosion_window)
erosion_shape = morph_shape(cv.getTrackbarPos(title_trackbar_element_shape, title_erosion_window))
 
    
element = cv.getStructuringElement(erosion_shape, (2 * erosion_size + 1, 2 * erosion_size + 1),
(erosion_size, erosion_size))
    
erosion_dst = cv.erode(src, element)
    cv.imshow(title_erosion_window, erosion_dst)

执行腐蚀操作的函数是 cv::erode 。如我们所见，它接收两个参数并返回处理后的图像

• src：源图像

• element：我们将用于执行操作的内核。我们可以通过使用函数 cv::getStructuringElement 来指定其形状

  element = cv.getStructuringElement(erosion_shape, (2 * erosion_size + 1, 2 * erosion_size + 1),
  (erosion_size, erosion_size))

  我们可以为内核选择以下三种形状中的任何一种

  • 矩形框：MORPH_RECT
  • 十字形：MORPH_CROSS
  • 椭圆形：MORPH_ELLIPSE
  • 菱形：MORPH_DIAMOND

然后，我们只需指定内核的大小和锚点。如果未指定锚点，则假定其在中心。

就是这样。我们准备好对图像进行腐蚀。

膨胀函数 (Python)

代码如下所示。如您所见，它与腐蚀的代码片段完全相似。在这里，我们还可以选择定义我们的内核、其锚点以及要使用的操作符的大小。

def dilatation(val)
dilatation_size = cv.getTrackbarPos(title_trackbar_kernel_size, title_dilation_window)
dilation_shape = morph_shape(cv.getTrackbarPos(title_trackbar_element_shape, title_dilation_window))
 
element = cv.getStructuringElement(dilation_shape, (2 * dilatation_size + 1, 2 * dilatation_size + 1),
(dilatation_size, dilatation_size))
dilatation_dst = cv.dilate(src, element)
    cv.imshow(title_dilation_window, dilatation_dst)

注意

此外，还有其他参数允许您一次执行多次腐蚀/膨胀（迭代），还可以设置边界类型和值。但是，在这个简单的教程中我们没有使用这些。您可以查看参考资料以获取更多详细信息。

结果

编译上面的代码并使用图像作为参数执行它（如果使用 Python，则运行脚本）。如果您不提供图像作为参数，将使用默认示例图像（LinuxLogo.jpg）。

例如，使用此图像

我们得到以下结果。改变跟踪条中的索引自然会产生不同的输出图像。尝试一下！您甚至可以尝试添加第三个跟踪条来控制迭代次数。

（根据编程语言，输出可能略有不同或只有 1 个窗口）