腐蝕和膨脹

目錄

• 目標
• 形態學操作
  • 膨脹
  • 腐蝕
• 程式碼
• 解釋
  • 腐蝕函式 (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 個視窗）