腐蚀和膨胀

目录

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

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

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

目标

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

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

注意

以下说明属于 Bradski 和 Kaehler 合著的《OpenCV 学习指南》一书。

形态学操作

• 简而言之：根据形状处理图像的一系列操作。形态学操作将结构元素应用于输入图像并生成输出图像。
• 最基本的形态学操作是：腐蚀和膨胀。它们有着广泛的应用，例如：
  • 除去噪点
  • 分离图像中的单个元素，并连接各个元素。
  • 查找图像中的强度凸起或孔洞
• 我们将通过以下图像作为示例，简要解释膨胀和腐蚀

膨胀

• 此运算包括使用某种内核（\(B\））对图像 \(A\) 进行卷积，该内核可以具有任意形状或大小，通常是正方形或圆形。
• 内核 \(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 = 2;
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 << "Could not open or find the image!\n" << endl;
cout << "Usage: " << argv[0] << " <Input image>" << endl;
    return -1;
  }
 
namedWindow( "Erosion Demo", WINDOW_AUTOSIZE );
namedWindow( "Dilation Demo", WINDOW_AUTOSIZE );
moveWindow( "Dilation Demo", src.cols, 0 );
 
createTrackbar( "元素：\n 0：矩形\n 1：十字\n 2：椭圆", "腐蚀示例",
&erosion_elem, max_elem,
Erosion );
 
createTrackbar( "内核大小：\n 2n +1", "腐蚀示例",
&erosion_size, max_kernel_size,
Erosion );
 
createTrackbar( "元素：\n 0：矩形\n 1：十字\n 2：椭圆", "膨胀示例",
&dilation_elem, max_elem,
Dilation );
 
createTrackbar( "内核大小：\n 2n +1", "膨胀示例",
&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; }
 
  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_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; }
 
  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_dst );
}

Java

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

导入 java.awt.BorderLayout;
导入 java.awt.Container;
导入 java.awt.Image;
导入 java.awt.event.ActionEvent;
导入 java.awt.event.ActionListener;
 
导入 javax.swing.BoxLayout;
导入 javax.swing.ImageIcon;
导入 javax.swing.JComboBox;
导入 javax.swing.JFrame;
导入 javax.swing.JLabel;
导入 javax.swing.JPanel;
导入 javax.swing.JSlider;
导入 javax.swing.event.ChangeEvent;
导入 javax.swing.event.ChangeListener;
 
导入 org.opencv.core.Core;
导入 org.opencv.core.Mat;
导入 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 = { "矩形", "十字形", "椭圆形" };
    private static final String[] MORPH_OP = { "腐蚀", "膨胀" };
    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("空图像：" + imagePath);
System.exit(0);
        }
 
        // 创建并设置窗口。
frame = new JFrame("腐蚀和膨胀演示");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 设置内容窗格。
Image img = HighGui.toBufferedImage(matImgSrc);
addComponentsToPane(frame.getContentPane(), img);
        // 使用内容窗格的默认边界布局。无需
        // setLayout(new BorderLayout());
        // 显示窗口。
frame.pack();
frame.setVisible(true);
    }
 
    private void addComponentsToPane(Container pane, Image img) {
        if (!(pane.getLayout() instanceof BorderLayout)) {
pane.add(new JLabel("该容器未采用边界布局！"));
            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;
                }
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
            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 = 2
max_kernel_size = 21
title_trackbar_element_shape = '元素：\n 0：矩形 \n 1：交叉 \n 2：椭圆'
title_trackbar_kernel_size = '核大小：\n 2n + 1'
title_erosion_window = '侵蚀示例'
title_dilation_window = '膨胀示例'
 
 
 
def main(image)
    global src
src = cv.imread(cv.samples.findFile(image))
    if src is None
print('无法打开或找到图像: ', 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
 
 
 
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='Eroding and Dilating tutorial 的代码.')
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 << "Could not open or find the image!\n" << endl;
cout << "Usage: " << argv[0] << " <Input image>" << endl;
    return -1;
  }
 
namedWindow( "Erosion Demo", WINDOW_AUTOSIZE );
namedWindow( "Dilation Demo", WINDOW_AUTOSIZE );
moveWindow( "Dilation Demo", src.cols, 0 );
 
createTrackbar( "元素：\n 0：矩形\n 1：十字\n 2：椭圆", "腐蚀示例",
&erosion_elem, max_elem,
Erosion );
 
createTrackbar( "内核大小：\n 2n +1", "腐蚀示例",
&erosion_size, max_kernel_size,
Erosion );
 
createTrackbar( "元素：\n 0：矩形\n 1：十字\n 2：椭圆", "膨胀示例",
&dilation_elem, max_elem,
Dilation );
 
createTrackbar( "内核大小：\n 2n +1", "膨胀示例",
&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; }
 
  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_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

  然后，我们只需指定内核的大小和锚点即可。如果没有指定，则假定它在中心。

就这样。我们已准备好执行图像的侵蚀。

膨胀函数 (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; }
 
  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("该容器未采用边界布局！"));
            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;
                }
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
            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('无法打开或找到图像: ', 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. 分别调用一次腐蚀和膨胀以显示初始图像

每次移动任意滑块，都会调用用户的腐蚀或膨胀函数，它会根据当前轨迹条值更新输出图像。

我们来分析一下这两个函数

腐蚀函数（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

接下来，只需指定我们的内核大小和锚点即可。如果未指定锚点，则默认位于中心。

就这样。我们已准备好执行图像的侵蚀。

膨胀函数（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)。

例如，使用此图像

将获得以下结果。自然地，在轨道中改变索引值会产生不同的输出图像。不妨试一试！您甚至还可以尝试添加第三个轨道来控制迭代次数。

（取决于编程语言，输出可能略有不同，或者只有一个窗口）