使用形态学操作提取水平和垂直线

目录

• 目标
• 理论
  • 形态学操作
  • 结构元素
• 代码
• 解释 / 结果
  • 加载图像
  • 灰度化
  • 灰度图像到二值图像
  • 输出图像
  • 结构元素
  • 边缘细化 / 结果

上一个教程： 击中或击不中变换
下一个教程： 图像金字塔

原始作者	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)