使用形態學操作提取水平和垂直線

目錄

• 目標
• 理論
  • 形態學操作
  • 結構元素
• 程式碼
• 解釋 / 結果
  • 載入影像
  • 灰度化
  • 灰度影像到二值影像
  • 輸出影像
  • 結構元素
  • 邊緣細化 / 結果

上一個教程： 擊中或擊不中變換
下一個教程： 影像金字塔

原始作者	Theodore Tsesmelis
相容性	OpenCV >= 3.0

目標

在本教程中，您將學習如何

• 應用兩種非常常見的形態學運算子（即膨脹和腐蝕），並建立自定義核，以提取水平和垂直軸上的直線。為此，您將使用以下OpenCV函式

  • erode()
  • dilate()
  • getStructuringElement()

  在一個示例中，您的目標是從樂譜中提取音符。

理論

形態學操作

形態學是一組影像處理操作，它基於預定義的結構元素（也稱為核）處理影像。輸出影像中每個畫素的值是基於輸入影像中相應畫素與其鄰域的比較。透過選擇核的大小和形狀，您可以構建對輸入影像中特定形狀敏感的形態學操作。

最基本的兩種形態學操作是膨脹和腐蝕。膨脹在影像中物件的邊界上新增畫素，而腐蝕則恰好相反。新增或移除的畫素數量分別取決於用於處理影像的結構元素的大小和形狀。通常，這兩種操作遵循的規則如下：

• 膨脹：輸出畫素的值是落入結構元素大小和形狀範圍內的所有畫素的最大值。例如，在二值影像中，如果落入核範圍內的任何輸入影像畫素被設定為值1，則輸出影像的相應畫素也將被設定為1。後者適用於任何型別的影像（例如灰度、BGR等）。

二值影像上的膨脹

灰度影像上的膨脹

• 腐蝕：腐蝕操作則相反。輸出畫素的值是落入結構元素大小和形狀範圍內的所有畫素的最小值。請看下面的示例圖：

二值影像上的腐蝕

灰度影像上的腐蝕

結構元素

如上所示，通常在任何形態學操作中，用於探測輸入影像的結構元素是最重要的部分。

結構元素是一個只包含0和1的矩陣，它可以是任意形狀和大小。通常它比被處理的影像小得多，而值為1的畫素定義了鄰域。結構元素的中心畫素，稱為原點，標識了目標畫素——即正在處理的畫素。

例如，下圖展示了一個7x7大小的菱形結構元素。

一個菱形結構元素及其原點

結構元素可以有許多常見的形狀和大小，例如線形、菱形、圓盤形、週期線形和圓形。您通常會選擇與輸入影像中要處理/提取的物件具有相同大小和形狀的結構元素。例如，要在影像中查詢線條，可以建立一個線性結構元素，稍後您將看到。

程式碼

本教程的程式碼如下所示。

C++

您也可以從此處下載。

 
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
 
void show_wait_destroy(const char* winname, cv::Mat img);
 
using namespace std;
using namespace cv;
 
int main(int argc, char** argv)
{
    CommandLineParser parser(argc, argv, "{@input | notes.png | input image}");
    Mat 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;
    }
 
    // Show source image
imshow("src", src);
 
    // Transform source image to gray if it is not already
    Mat gray;
 
    if (src.channels() == 3)
    {
cvtColor(src, gray, COLOR_BGR2GRAY);
    }
    else
    {
gray = src;
    }
 
    // Show gray image
show_wait_destroy("gray", gray);
 
    // Apply adaptiveThreshold at the bitwise_not of gray, notice the ~ symbol
    Mat bw;
adaptiveThreshold(~gray, bw, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 15, -2);
 
    // Show binary image
show_wait_destroy("binary", bw);
 
    // Create the images that will use to extract the horizontal and vertical lines
    Mat horizontal = bw.clone();
    Mat vertical = bw.clone();
 
    // Specify size on horizontal axis
    int horizontal_size = horizontal.cols / 30;
 
    // Create structure element for extracting horizontal lines through morphology operations
    Mat horizontalStructure = getStructuringElement(MORPH_RECT, Size(horizontal_size, 1));
 
    // Apply morphology operations
erode(horizontal, horizontal, horizontalStructure, Point(-1, -1));
dilate(horizontal, horizontal, horizontalStructure, Point(-1, -1));
 
    // Show extracted horizontal lines
show_wait_destroy("horizontal", horizontal);
 
    // Specify size on vertical axis
    int vertical_size = vertical.rows / 30;
 
    // Create structure element for extracting vertical lines through morphology operations
    Mat verticalStructure = getStructuringElement(MORPH_RECT, Size(1, vertical_size));
 
    // Apply morphology operations
erode(vertical, vertical, verticalStructure, Point(-1, -1));
dilate(vertical, vertical, verticalStructure, Point(-1, -1));
 
    // Show extracted vertical lines
show_wait_destroy("vertical", vertical);
 
    // Inverse vertical image
bitwise_not(vertical, vertical);
show_wait_destroy("vertical_bit", vertical);
 
    // Extract edges and smooth image according to the logic
    // 1. extract edges
    // 2. dilate(edges)
    // 3. src.copyTo(smooth)
    // 4. blur smooth img
    // 5. smooth.copyTo(src, edges)
 
    // Step 1
    Mat edges;
adaptiveThreshold(vertical, edges, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 3, -2);
show_wait_destroy("edges", edges);
 
    // Step 2
    Mat kernel = Mat::ones(2, 2, CV_8UC1);
dilate(edges, edges, kernel);
show_wait_destroy("dilate", edges);
 
    // Step 3
    Mat smooth;
vertical.copyTo(smooth);
 
    // Step 4
blur(smooth, smooth, Size(2, 2));
 
    // Step 5
smooth.copyTo(vertical, edges);
 
    // Show final result
show_wait_destroy("smooth - final", vertical);
 
    return 0;
}
 
void show_wait_destroy(const char* winname, cv::Mat img) {
    imshow(winname, img);
    moveWindow(winname, 500, 0);
    waitKey(0);
    destroyWindow(winname);
}

Java

您也可以從此處下載。

 
import org.opencv.core.*;
import org.opencv.highgui.HighGui;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
 
class Morphology_3Run {
 
    public void run(String[] args) {
 
        // Check number of arguments
        if (args.length == 0){
System.out.println("Not enough parameters!");
System.out.println("Program Arguments: [image_path]");
System.exit(-1);
        }
 
        // Load the image
Mat src = Imgcodecs.imread(args[0]);
 
        // 檢查影像是否載入成功
        if( src.empty() ) {
System.out.println("Error opening image: " + args[0]);
System.exit(-1);
        }
 
        // Show source image
HighGui.imshow("src", src);
 
        // Transform source image to gray if it is not already
Mat gray = new Mat();
 
        if (src.channels() == 3)
        {
Imgproc.cvtColor(src, gray, Imgproc.COLOR_BGR2GRAY);
        }
        else
        {
gray = src;
        }
 
        // Show gray image
showWaitDestroy("gray" , gray);
 
        // Apply adaptiveThreshold at the bitwise_not of gray
Mat bw = new Mat();
Core.bitwise_not(gray, gray);
Imgproc.adaptiveThreshold(gray, bw, 255, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 15, -2);
 
        // Show binary image
showWaitDestroy("binary" , bw);
 
        // Create the images that will use to extract the horizontal and vertical lines
Mat horizontal = bw.clone();
Mat vertical = bw.clone();
 
        // Specify size on horizontal axis
        int horizontal_size = horizontal.cols() / 30;
 
        // Create structure element for extracting horizontal lines through morphology operations
Mat horizontalStructure = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(horizontal_size,1));
 
        // Apply morphology operations
Imgproc.erode(horizontal, horizontal, horizontalStructure);
Imgproc.dilate(horizontal, horizontal, horizontalStructure);
 
        // Show extracted horizontal lines
showWaitDestroy("horizontal" , horizontal);
 
        // Specify size on vertical axis
        int vertical_size = vertical.rows() / 30;
 
        // Create structure element for extracting vertical lines through morphology operations
Mat verticalStructure = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size( 1,vertical_size));
 
        // Apply morphology operations
Imgproc.erode(vertical, vertical, verticalStructure);
Imgproc.dilate(vertical, vertical, verticalStructure);
 
        // Show extracted vertical lines
showWaitDestroy("vertical", vertical);
 
        // Inverse vertical image
Core.bitwise_not(vertical, vertical);
showWaitDestroy("vertical_bit" , vertical);
 
        // Extract edges and smooth image according to the logic
        // 1. extract edges
        // 2. dilate(edges)
        // 3. src.copyTo(smooth)
        // 4. blur smooth img
        // 5. smooth.copyTo(src, edges)
 
        // Step 1
Mat edges = new Mat();
Imgproc.adaptiveThreshold(vertical, edges, 255, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 3, -2);
showWaitDestroy("edges", edges);
 
        // Step 2
Mat kernel = Mat.ones(2, 2, CvType.CV_8UC1);
Imgproc.dilate(edges, edges, kernel);
showWaitDestroy("dilate", edges);
 
        // Step 3
Mat smooth = new Mat();
vertical.copyTo(smooth);
 
        // Step 4
Imgproc.blur(smooth, smooth, new Size(2, 2));
 
        // Step 5
smooth.copyTo(vertical, edges);
 
        // Show final result
showWaitDestroy("smooth - final", vertical);
 
System.exit(0);
    }
 
    private void showWaitDestroy(String winname, Mat img) {
HighGui.imshow(winname, img);
HighGui.moveWindow(winname, 500, 0);
HighGui.waitKey(0);
HighGui.destroyWindow(winname);
    }
}
 
public class Morphology_3 {
    public static void main(String[] args) {
        // 載入本地庫。
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
        new Morphology_3Run().run(args);
    }
}

Python

您也可以從此處下載。

"""
@file morph_lines_detection.py
@簡介 使用形態學變換提取水平和垂直線的示例程式碼
"""
import numpy as np
import sys
import cv2 as cv
 
 
def show_wait_destroy(winname, img)
    cv.imshow(winname, img)
    cv.moveWindow(winname, 500, 0)
    cv.waitKey(0)
    cv.destroyWindow(winname)
 
 
def main(argv)
    # [load_image]
    # Check number of arguments
    if len(argv) < 1
        print ('Not enough parameters')
        print ('Usage:\nmorph_lines_detection.py < path_to_image >')
        return -1
 
    # Load the image
src = cv.imread(argv[0], cv.IMREAD_COLOR)
 
    # Check if image is loaded fine
    if src is None
        print ('Error opening image: ' + argv[0])
        return -1
 
    # Show source image
    cv.imshow("src", src)
    # [load_image]
 
    # [gray]
    # Transform source image to gray if it is not already
    if len(src.shape) != 2
gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
    else:
gray = src
 
    # Show gray image
show_wait_destroy("gray", gray)
    # [gray]
 
    # [bin]
    # Apply adaptiveThreshold at the bitwise_not of gray, notice the ~ symbol
gray = cv.bitwise_not(gray)
bw = cv.adaptiveThreshold(gray, 255, cv.ADAPTIVE_THRESH_MEAN_C, \
cv.THRESH_BINARY, 15, -2)
    # Show binary image
show_wait_destroy("binary", bw)
    # [bin]
 
    # [init]
    # Create the images that will use to extract the horizontal and vertical lines
horizontal = np.copy(bw)
vertical = np.copy(bw)
    # [init]
 
    # [horiz]
    # Specify size on horizontal axis
cols = horizontal.shape[1]
horizontal_size = cols // 30
 
    # Create structure element for extracting horizontal lines through morphology operations
horizontalStructure = cv.getStructuringElement(cv.MORPH_RECT, (horizontal_size, 1))
 
    # Apply morphology operations
horizontal = cv.erode(horizontal, horizontalStructure)
horizontal = cv.dilate(horizontal, horizontalStructure)
 
    # Show extracted horizontal lines
show_wait_destroy("horizontal", horizontal)
    # [horiz]
 
    # [vert]
    # Specify size on vertical axis
rows = vertical.shape[0]
verticalsize = rows // 30
 
    # Create structure element for extracting vertical lines through morphology operations
verticalStructure = cv.getStructuringElement(cv.MORPH_RECT, (1, verticalsize))
 
    # Apply morphology operations
vertical = cv.erode(vertical, verticalStructure)
vertical = cv.dilate(vertical, verticalStructure)
 
    # Show extracted vertical lines
show_wait_destroy("vertical", vertical)
    # [vert]
 
    # [smooth]
    # Inverse vertical image
vertical = cv.bitwise_not(vertical)
show_wait_destroy("vertical_bit", vertical)
 
    '''
根據以下邏輯提取邊緣並平滑影像：
1. 提取邊緣
2. 膨脹邊緣
3. src.copyTo(smooth)
4. 模糊平滑影像
5. smooth.copyTo(src, edges)
    '''
 
    # Step 1
edges = cv.adaptiveThreshold(vertical, 255, cv.ADAPTIVE_THRESH_MEAN_C, \
cv.THRESH_BINARY, 3, -2)
show_wait_destroy("edges", edges)
 
    # Step 2
kernel = np.ones((2, 2), np.uint8)
edges = cv.dilate(edges, kernel)
show_wait_destroy("dilate", edges)
 
    # Step 3
smooth = np.copy(vertical)
 
    # Step 4
smooth = cv.blur(smooth, (2, 2))
 
    # Step 5
(rows, cols) = np.where(edges != 0)
vertical[rows, cols] = smooth[rows, cols]
 
    # Show final result
show_wait_destroy("smooth - final", vertical)
    # [smooth]
 
    return 0
 
if __name__ == "__main__"
    main(sys.argv[1:])

解釋 / 結果

從此處獲取影像。

載入影像

C++

    CommandLineParser parser(argc, argv, "{@input | notes.png | input image}");
    Mat 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;
    }
 
    // Show source image
    imshow("src", src);

Java

        // Check number of arguments
        if (args.length == 0){
System.out.println("Not enough parameters!");
System.out.println("Program Arguments: [image_path]");
System.exit(-1);
        }
 
        // Load the image
Mat src = Imgcodecs.imread(args[0]);
 
        // 檢查影像是否載入成功
        if( src.empty() ) {
System.out.println("Error opening image: " + args[0]);
System.exit(-1);
        }
 
        // Show source image
HighGui.imshow("src", src);

Python

    # Check number of arguments
    if len(argv) < 1
        print ('Not enough parameters')
        print ('Usage:\nmorph_lines_detection.py < path_to_image >')
        return -1
 
    # Load the image
src = cv.imread(argv[0], cv.IMREAD_COLOR)
 
    # Check if image is loaded fine
    if src is None
        print ('Error opening image: ' + argv[0])
        return -1
 
    # Show source image
    cv.imshow("src", src)

灰度化

C++

    // Transform source image to gray if it is not already
    Mat gray;
 
    if (src.channels() == 3)
    {
        cvtColor(src, gray, COLOR_BGR2GRAY);
    }
    else
    {
gray = src;
    }
 
    // Show gray image
show_wait_destroy("gray", gray);

Java

        // Transform source image to gray if it is not already
Mat gray = new Mat();
 
        if (src.channels() == 3)
        {
Imgproc.cvtColor(src, gray, Imgproc.COLOR_BGR2GRAY);
        }
        else
        {
gray = src;
        }
 
        // Show gray image
showWaitDestroy("gray" , gray);

Python

    # Transform source image to gray if it is not already
    if len(src.shape) != 2
gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
    else:
gray = src
 
    # Show gray image
show_wait_destroy("gray", gray)

灰度到二值影像

C++

    // Apply adaptiveThreshold at the bitwise_not of gray, notice the ~ symbol
    Mat bw;
    adaptiveThreshold(~gray, bw, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 15, -2);
 
    // Show binary image
show_wait_destroy("binary", bw);

Java

        // Apply adaptiveThreshold at the bitwise_not of gray
Mat bw = new Mat();
Core.bitwise_not(gray, gray);
Imgproc.adaptiveThreshold(gray, bw, 255, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 15, -2);
 
        // Show binary image
showWaitDestroy("binary" , bw);

Python

    # Apply adaptiveThreshold at the bitwise_not of gray, notice the ~ symbol
gray = cv.bitwise_not(gray)
bw = cv.adaptiveThreshold(gray, 255, cv.ADAPTIVE_THRESH_MEAN_C, \
cv.THRESH_BINARY, 15, -2)
    # Show binary image
show_wait_destroy("binary", bw)

輸出影像

現在我們準備應用形態學操作，以提取水平和垂直線，從而將音符從樂譜中分離出來，但首先讓我們初始化為此目的將使用的輸出影像。

C++

    // Create the images that will use to extract the horizontal and vertical lines
    Mat horizontal = bw.clone();
    Mat vertical = bw.clone();

Java

        // Create the images that will use to extract the horizontal and vertical lines
Mat horizontal = bw.clone();
Mat vertical = bw.clone();

Python

    # Create the images that will use to extract the horizontal and vertical lines
horizontal = np.copy(bw)
vertical = np.copy(bw)

結構元素

正如我們在理論部分所闡述的，為了提取我們想要的物件，我們需要建立相應的結構元素。由於我們要提取水平線，為此目的的相應結構元素將具有以下形狀：

在原始碼中，這由以下程式碼片段表示：

C++

    // Specify size on horizontal axis
    int horizontal_size = horizontal.cols / 30;
 
    // Create structure element for extracting horizontal lines through morphology operations
    Mat horizontalStructure = getStructuringElement(MORPH_RECT, Size(horizontal_size, 1));
 
    // Apply morphology operations
    erode(horizontal, horizontal, horizontalStructure, Point(-1, -1));
    dilate(horizontal, horizontal, horizontalStructure, Point(-1, -1));
 
    // Show extracted horizontal lines
show_wait_destroy("horizontal", horizontal);

Java

        // Specify size on horizontal axis
        int horizontal_size = horizontal.cols() / 30;
 
        // Create structure element for extracting horizontal lines through morphology operations
Mat horizontalStructure = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(horizontal_size,1));
 
        // Apply morphology operations
Imgproc.erode(horizontal, horizontal, horizontalStructure);
Imgproc.dilate(horizontal, horizontal, horizontalStructure);
 
        // Show extracted horizontal lines
showWaitDestroy("horizontal" , horizontal);

Python

    # Specify size on horizontal axis
cols = horizontal.shape[1]
horizontal_size = cols // 30
 
    # Create structure element for extracting horizontal lines through morphology operations
horizontalStructure = cv.getStructuringElement(cv.MORPH_RECT, (horizontal_size, 1))
 
    # Apply morphology operations
horizontal = cv.erode(horizontal, horizontalStructure)
horizontal = cv.dilate(horizontal, horizontalStructure)
 
    # Show extracted horizontal lines
show_wait_destroy("horizontal", horizontal)

對於垂直線，同樣適用，其相應的結構元素為：

同樣，這表示如下：

C++

    // Specify size on vertical axis
    int vertical_size = vertical.rows / 30;
 
    // Create structure element for extracting vertical lines through morphology operations
    Mat verticalStructure = getStructuringElement(MORPH_RECT, Size(1, vertical_size));
 
    // Apply morphology operations
    erode(vertical, vertical, verticalStructure, Point(-1, -1));
    dilate(vertical, vertical, verticalStructure, Point(-1, -1));
 
    // Show extracted vertical lines
show_wait_destroy("vertical", vertical);

Java

        // Specify size on vertical axis
        int vertical_size = vertical.rows() / 30;
 
        // Create structure element for extracting vertical lines through morphology operations
Mat verticalStructure = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size( 1,vertical_size));
 
        // Apply morphology operations
Imgproc.erode(vertical, vertical, verticalStructure);
Imgproc.dilate(vertical, vertical, verticalStructure);
 
        // Show extracted vertical lines
showWaitDestroy("vertical", vertical);

Python

    # Specify size on vertical axis
rows = vertical.shape[0]
verticalsize = rows // 30
 
    # Create structure element for extracting vertical lines through morphology operations
verticalStructure = cv.getStructuringElement(cv.MORPH_RECT, (1, verticalsize))
 
    # Apply morphology operations
vertical = cv.erode(vertical, verticalStructure)
vertical = cv.dilate(vertical, verticalStructure)
 
    # Show extracted vertical lines
show_wait_destroy("vertical", vertical)

邊緣細化 / 結果

如您所見，我們已經接近目標了。然而，此時您會注意到音符的邊緣有些粗糙。因此，我們需要對邊緣進行細化以獲得更平滑的結果。

C++

    // Inverse vertical image
    bitwise_not(vertical, vertical);
show_wait_destroy("vertical_bit", vertical);
 
    // Extract edges and smooth image according to the logic
    // 1. extract edges
    // 2. dilate(edges)
    // 3. src.copyTo(smooth)
    // 4. blur smooth img
    // 5. smooth.copyTo(src, edges)
 
    // Step 1
    Mat edges;
    adaptiveThreshold(vertical, edges, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 3, -2);
show_wait_destroy("edges", edges);
 
    // Step 2
    Mat kernel = Mat::ones(2, 2, CV_8UC1);
    dilate(edges, edges, kernel);
show_wait_destroy("dilate", edges);
 
    // Step 3
    Mat smooth;
vertical.copyTo(smooth);
 
    // Step 4
    blur(smooth, smooth, Size(2, 2));
 
    // Step 5
smooth.copyTo(vertical, edges);
 
    // Show final result
show_wait_destroy("smooth - final", vertical);

Java

        // Inverse vertical image
Core.bitwise_not(vertical, vertical);
showWaitDestroy("vertical_bit" , vertical);
 
        // Extract edges and smooth image according to the logic
        // 1. extract edges
        // 2. dilate(edges)
        // 3. src.copyTo(smooth)
        // 4. blur smooth img
        // 5. smooth.copyTo(src, edges)
 
        // Step 1
Mat edges = new Mat();
Imgproc.adaptiveThreshold(vertical, edges, 255, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 3, -2);
showWaitDestroy("edges", edges);
 
        // Step 2
Mat kernel = Mat.ones(2, 2, CvType.CV_8UC1);
Imgproc.dilate(edges, edges, kernel);
showWaitDestroy("dilate", edges);
 
        // Step 3
Mat smooth = new Mat();
vertical.copyTo(smooth);
 
        // Step 4
Imgproc.blur(smooth, smooth, new Size(2, 2));
 
        // Step 5
smooth.copyTo(vertical, edges);
 
        // Show final result
showWaitDestroy("smooth - final", vertical);

Python

    # Inverse vertical image
vertical = cv.bitwise_not(vertical)
show_wait_destroy("vertical_bit", vertical)
 
    '''
根據以下邏輯提取邊緣並平滑影像：
1. 提取邊緣
2. 膨脹邊緣
3. src.copyTo(smooth)
4. 模糊平滑影像
5. smooth.copyTo(src, edges)
    '''
 
    # Step 1
edges = cv.adaptiveThreshold(vertical, 255, cv.ADAPTIVE_THRESH_MEAN_C, \
cv.THRESH_BINARY, 3, -2)
show_wait_destroy("edges", edges)
 
    # Step 2
kernel = np.ones((2, 2), np.uint8)
edges = cv.dilate(edges, kernel)
show_wait_destroy("dilate", edges)
 
    # Step 3
smooth = np.copy(vertical)
 
    # Step 4
smooth = cv.blur(smooth, (2, 2))
 
    # Step 5
(rows, cols) = np.where(edges != 0)
vertical[rows, cols] = smooth[rows, cols]
 
    # Show final result
show_wait_destroy("smooth - final", vertical)