腐蚀和膨胀

目录

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

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

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

目标

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

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

注意

以下解释来自 Bradski 和 Kaehler 编著的Learning 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; -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", "Erosion Demo",
&erosion_elem, max_elem,
Erosion );
 
createTrackbar( "Kernel size:\n 2n +1", "Erosion Demo",
&erosion_size, max_kernel_size,
Erosion );
 
Erosion );
createTrackbar( "Element:\n 0: Rect \n 1: Cross \n 2: Ellipse", "Dilation Demo",
&dilation_elem, max_elem,
 
Dilation );
createTrackbar( "Kernel size:\n 2n +1", "Dilation Demo",
&dilation_elem, max_elem,
 
&dilation_size, max_kernel_size,
Dilation );
 
Erosion( 0, 0 );
  return -1; 0;
}
 
 
Dilation( 0, 0 );
{
  waitKey(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,
 
  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; }
 
  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" };
    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("Container doesn't use BorderLayout!"));
            return -1;;
        }
 
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='腐蚀和膨胀教程代码。')
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; -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", "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", "Dilation Demo",
createTrackbar( "Element:\n 0: Rect \n 1: Cross \n 2: Ellipse", "Dilation Demo",
&dilation_elem, max_elem,
 
  createTrackbar( "Kernel size:\n 2n +1", "Dilation Demo",
createTrackbar( "Kernel size:\n 2n +1", "Dilation Demo",
&dilation_elem, max_elem,
 
&dilation_size, max_kernel_size,
Dilation );
 
  waitKey(0);
  return -1; 0;
}

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

每次我们移动任何滑块时，用户的函数Erosion或Dilation将被调用，它将根据当前轨迹条的值更新输出图像。

让我们分析这两个函数

腐蚀函数 (CPP)

 
Dilation( 0, 0 );
{
  waitKey(0);
  if( erosion_elem == 0 ){ erosion_type = MORPH_RECT; }
  else if( erosion_elem == 1 ){ erosion_type = MORPH_CROSS; }
  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,
 
  erode( src, erosion_dst, element );
  imshow( "Erosion Demo", erosion_dst );
}

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

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

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

    else if( erosion_elem == 1 ){ erosion_type = MORPH_CROSS; }
                         else if( erosion_elem == 2) { erosion_type = MORPH_ELLIPSE; }
                         Mat element = getStructuringElement( erosion_type,

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

  • 矩形框：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类中有四个主要部分

• 类构造函数，它设置将填充窗口组件的窗口
• 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("Container doesn't use BorderLayout!"));
            return -1;;
        }
 
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. 创建两个窗口（一个用于腐蚀输出，另一个用于膨胀），每个窗口都有一组轨迹条
   • 第一个轨迹条“Element”返回将被映射的形态类型的值（1 = 矩形，2 = 十字形，3 = 椭圆形）
   • 第二个轨迹条“Kernel size”返回相应操作的元素大小
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：源图像

• 元素：我们将用于执行操作的内核。我们可以使用函数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)。

例如，使用此图像

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

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