腐蚀和膨胀

目录

• 目标
• 形态学操作
  • 膨胀
  • 腐蚀
• 代码
• 解释
  • 腐蚀函数 (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( "腐蚀演示", WINDOW_AUTOSIZE );
namedWindow( "膨胀演示", WINDOW_AUTOSIZE );
moveWindow( "膨胀演示", src.cols, 0 );
 
createTrackbar( "元素:\n 0: 矩形 \n 1: 十字形 \n 2: 椭圆形 \n 3: 菱形", "腐蚀演示",
&erosion_elem, max_elem,
Erosion );
 
createTrackbar( "核大小:\n 2n +1", "腐蚀演示",
&erosion_size, max_kernel_size,
Erosion );
 
createTrackbar( "元素:\n 0: 矩形 \n 1: 十字形 \n 2: 椭圆形 \n 3: 菱形", "膨胀演示",
&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; }
  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_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_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 = { "矩形", "十字形", "椭圆形", "菱形" };
    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);
        }
 
        // Create and set up the window.
frame = new JFrame("腐蚀与膨胀演示");
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("容器未使用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("核大小: 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);
 
        // 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 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 = '元素:\n 0: 矩形 \n 1: 十字形 \n 2: 椭圆形 \n 3: 菱形'
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()
 
 
# optional mapping of values with morphological shapes
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( "腐蚀演示", WINDOW_AUTOSIZE );
  namedWindow( "膨胀演示", WINDOW_AUTOSIZE );
  moveWindow( "膨胀演示", src.cols, 0 );
 
  createTrackbar( "元素:\n 0: 矩形 \n 1: 十字形 \n 2: 椭圆形 \n 3: 菱形", "腐蚀演示",
&erosion_elem, max_elem,
Erosion );
 
  createTrackbar( "核大小:\n 2n +1", "腐蚀演示",
&erosion_size, max_kernel_size,
Erosion );
 
  createTrackbar( "元素:\n 0: 矩形 \n 1: 十字形 \n 2: 椭圆形 \n 3: 菱形", "膨胀演示",
&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; }
  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_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_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("核大小: 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. 调用一次腐蚀和膨胀以显示初始图像。

每次我们移动任何滑动条时，都会调用用户的 **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 个窗口）