使用形态学运算提取水平线和垂直线

目录

• 目标
• 理论
  • 形态学运算
  • 结构元素
• 代码
• 说明/结果
  • 加载图像
  • 灰度
  • 灰度转二值图像
  • 输出图像
  • 结构元素
  • 精炼边缘/结果

前一个教程： 撞击或遗漏
下一个教程： 图像金字塔

原作者	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;
    }
 
    // 显示源图像
imshow("src", src);
 
    // 若源图像不是灰度图像，则将其转换为灰度图像
    Mat gray;
 
    如果 (src.channels() == 3)
    {
cvtColor(src, gray, COLOR_BGR2GRAY);
    }
    其他
    {
gray = src;
    }
 
    // 显示灰度图像
show_wait_destroy("gray", gray);
 
    // 应用二值化反色阈值，请注意 ~ 符号
    Mat bw;
adaptiveThreshold(~gray, bw, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 15, -2);
 
    // 显示二值图像
show_wait_destroy("binary", bw);
 
    // 创建用于提取水平和垂直线段的图像
    Mat horizontal = bw.clone();
    Mat vertical = bw.clone();
 
    // 指定水平轴上的大小
    int horizontal_size = horizontal.cols / 30;
 
    // 创建用于通过形态学运算提取水平线段的结构元素
    Mat horizontalStructure = getStructuringElement(MORPH_RECT, Size(horizontal_size, 1));
 
    // 应用形态学运算
erode(horizontal, horizontal, horizontalStructure, Point(-1, -1));
dilate(horizontal, horizontal, horizontalStructure, Point(-1, -1));
 
    // 显示提取的水平线段
show_wait_destroy("horizontal", horizontal);
 
    // 指定垂直轴上的大小
    int vertical_size = vertical.rows / 30;
 
    // 创建用于通过形态学运算提取垂直线段的结构元素
    Mat verticalStructure = getStructuringElement(MORPH_RECT, Size(1, vertical_size));
 
    // 应用形态学运算
erode(vertical, vertical, verticalStructure, Point(-1, -1));
dilate(vertical, vertical, verticalStructure, Point(-1, -1));
 
    // 显示提取的垂直线段
show_wait_destroy("vertical", vertical);
 
    // 反转垂直图像
bitwise_not(vertical, vertical);
show_wait_destroy("vertical_bit", vertical);
 
    // 根据逻辑提取边缘并平滑图像
    // 1. 提取边缘
    // 2. 膨胀（边缘）
    // 3. src.copyTo(平滑)
    // 4. 模糊平滑图像
    // 5. 平滑.copyTo(src，边缘)
 
    // 步骤 1
    Mat edges;
adaptiveThreshold(vertical, edges, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 3, -2);
show_wait_destroy("edges", edges);
 
    // 步骤 2
    Mat 内核 = Mat::ones(2, 2, CV_8UC1);
dilate(边缘, 边缘, 内核);
show_wait_destroy("dilate", 边缘);
 
    // 步骤 3
    Mat 平滑;
垂直.copyTo(平滑);
 
    // 步骤 4
blur(平滑, 平滑, Size(2, 2));
 
    // 步骤 5
平滑.copyTo(垂直, 边缘);
 
    // 显示最终结果
show_wait_destroy("smooth - final", 垂直);
 
    return 0;
}
 
void show_wait_destroy(const char* 窗口名称, cv::Mat 图像) {
    imshow(窗口名称, 图像);
    moveWindow(窗口名称, 500, 0);
    waitKey(0);
    destroyWindow(窗口名称);
}

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) {
 
        // 检查参数数量
        if (args.length == 0){
System.out.println("Not enough parameters!");
System.out.println("Program Arguments: [image_path]");
System.exit(-1);
        }
 
        // 加载图像
Mat src = Imgcodecs.imread(args[0]);
 
        // 检查图像是否加载正常
        if( src.empty() ) {
System.out.println("Error opening image: " + args[0]);
System.exit(-1);
        }
 
        // 显示源图像
HighGui.imshow("src", src);
 
        // 若源图像不是灰度图像，则将其转换为灰度图像
Mat gray = new Mat();
 
        if (src.channels() == 3)
        {
Imgproc.cvtColor(src, gray, Imgproc.COLOR_BGR2GRAY);
        }
        其他
        {
gray = src;
        }
 
        // 显示灰度图像
showWaitDestroy("gray" , 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);
 
        // 显示二值图像
showWaitDestroy("binary" , bw);
 
        // 创建用于提取水平和垂直线段的图像
Mat horizontal = bw.clone();
Mat vertical = bw.clone();
 
        // 指定水平轴上的大小
        int horizontal_size = horizontal.cols() / 30;
 
        // 创建用于通过形态学运算提取水平线段的结构元素
Mat horizontalStructure = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(horizontal_size,1));
 
        // 应用形态学运算
Imgproc.erode(horizontal, horizontal, horizontalStructure);
Imgproc.dilate(horizontal, horizontal, horizontalStructure);
 
        // 显示提取的水平线段
showWaitDestroy("horizontal" , horizontal);
 
        // 指定垂直轴上的大小
        int vertical_size = vertical.rows() / 30;
 
        // 创建用于通过形态学运算提取垂直线段的结构元素
Mat verticalStructure = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size( 1,vertical_size));
 
        // 应用形态学运算
Imgproc.erode(vertical, vertical, verticalStructure);
Imgproc.dilate(vertical, vertical, verticalStructure);
 
        // 显示提取的垂直线段
showWaitDestroy("vertical", vertical);
 
        // 反转垂直图像
Core.bitwise_not(vertical, vertical);
showWaitDestroy("vertical_bit" , vertical);
 
        // 根据逻辑提取边缘并平滑图像
        // 1. 提取边缘
        // 2. 膨胀（边缘）
        // 3. src.copyTo(平滑)
        // 4. 模糊平滑图像
        // 5. 平滑.copyTo(src，边缘)
 
        // 步骤 1
Mat edges = new Mat();
Imgproc.adaptiveThreshold(vertical, edges, 255, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 3, -2);
showWaitDestroy("edges", edges);
 
        // 步骤 2
Mat kernel = Mat.ones(2, 2, CvType.CV_8UC1);
Imgproc.dilate(edges, edges, kernel);
showWaitDestroy("dilate", edges);
 
        // 步骤 3
Mat smooth = new Mat();
vertical.copyTo(smooth);
 
        // 步骤 4
Imgproc.blur(smooth, smooth, new Size(2, 2));
 
        // 步骤 5
smooth.copyTo(vertical, edges);
 
        // 显示最终结果
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
@brief 使用形态转换提取水平和垂直线样本代码
"""
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]
    # 检查参数数量
    if len(argv) < 1
        print ('Not enough parameters')
        print ('Usage:\nmorph_lines_detection.py < path_to_image >')
        return -1
 
    # 加载图像
src = cv.imread(argv[0], cv.IMREAD_COLOR)
 
    # 检查图像是否加载正确
    if src is None
        print ('Error opening image: ' + argv[0])
        return -1
 
    # 显示源图像
    cv.imshow("src", src)
    # [load_image]
 
    # [gray]
    # 如果源图像不是灰度图，则将其转换为灰度图
    if len(src.shape) != 2
gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
    其他:
gray = src
 
    # 显示灰度图
show_wait_destroy("gray", gray)
    # [gray]
 
    ＃ [二进制]
    ＃在灰度的 not 位上应用自适应阈值，注意 ~ 符号
gray = cv.bitwise_not(gray)
bw = cv.adaptiveThreshold(gray, 255, cv.ADAPTIVE_THRESH_MEAN_C, \
cv.THRESH_BINARY, 15, -2)
    ＃显示二进制图像
show_wait_destroy("binary", bw)
    ＃ [二进制]
 
    ＃ [init]
    ＃创建用于提取水平线和垂直线的图像
horizontal = np.copy(bw)
vertical = np.copy(bw)
    ＃ [init]
 
    ＃ [horiz]
    ＃指定水平轴上的尺寸
cols = horizontal.shape[1]
horizontal_size = cols // 30
 
    ＃通过形态学操作创建用于提取水平线的结构元素
horizontalStructure = cv.getStructuringElement(cv.MORPH_RECT, (horizontal_size, 1))
 
    ＃应用形态学操作
horizontal = cv.erode(horizontal, horizontalStructure)
horizontal = cv.dilate(horizontal, horizontalStructure)
 
    ＃显示提取的水平线
show_wait_destroy("horizontal", horizontal)
    ＃ [horiz]
 
    ＃ [vert]
    ＃指定垂直轴上的尺寸
rows = vertical.shape[0]
verticalsize = rows // 30
 
    ＃通过形态学操作创建用于提取垂直线的结构元素
verticalStructure = cv.getStructuringElement(cv.MORPH_RECT, (1, verticalsize))
 
    ＃应用形态学操作
vertical = cv.erode(vertical, verticalStructure)
vertical = cv.dilate(vertical, verticalStructure)
 
    ＃显示提取的垂直线
show_wait_destroy("vertical", vertical)
    ＃ [vert]
 
    ＃ [smooth]
    ＃反转垂直图像
vertical = cv.bitwise_not(vertical)
show_wait_destroy("vertical_bit", vertical)
 
    '''
根据以下逻辑提取边缘并平滑图像
1. 提取边缘
2. 膨胀（边缘）
3. src.copyTo(smooth)
4. 模糊 smooth 图像
5. smooth.copyTo(src, edges)
    '''
 
    ＃步骤 1
edges = cv.adaptiveThreshold(vertical, 255, cv.ADAPTIVE_THRESH_MEAN_C, \
cv.THRESH_BINARY, 3, -2)
show_wait_destroy("edges", edges)
 
    ＃步骤 2
kernel = np.ones((2, 2), np.uint8)
edges = cv.dilate(edges, kernel)
show_wait_destroy("dilate", edges)
 
    ＃步骤 3
smooth = np.copy(vertical)
 
    ＃步骤 4
smooth = cv.blur(smooth, (2, 2))
 
    ＃步骤 5
(行，列) = np.where(边缘不为 0)
垂直[行，列] = 平滑[行，列]
 
    # 展示最终结果
show_wait_destroy("平滑 - 最终结果", 垂直)
    ＃ [smooth]
 
    return 0
 
如果 __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;
    }
 
    // 显示源图像
imshow("src", src);

Java

        // 检查参数数量
        if (args.length == 0){
System.out.println("Not enough parameters!");
System.out.println("Program Arguments: [image_path]");
System.exit(-1);
        }
 
        // 加载图像
Mat src = Imgcodecs.imread(args[0]);
 
        // 检查图像是否加载正常
        if( src.empty() ) {
System.out.println("Error opening image: " + args[0]);
System.exit(-1);
        }
 
        // 显示源图像
HighGui.imshow("src", src);

Python

    # 检查参数数量
    if len(argv) < 1
        print ('Not enough parameters')
        print ('Usage:\nmorph_lines_detection.py < path_to_image >')
        return -1
 
    # 加载图像
src = cv.imread(argv[0], cv.IMREAD_COLOR)
 
    # 检查图像是否加载正确
    if src is None
        print ('Error opening image: ' + argv[0])
        return -1
 
    # 显示源图像
    cv.imshow("src", src)

灰度化

C++

    // 若源图像不是灰度图像，则将其转换为灰度图像
    Mat gray;
 
    如果 (src.channels() == 3)
    {
cvtColor(src, gray, COLOR_BGR2GRAY);
    }
    其他
    {
gray = src;
    }
 
    // 显示灰度图像
show_wait_destroy("gray", gray);

Java

        // 若源图像不是灰度图像，则将其转换为灰度图像
Mat gray = new Mat();
 
        if (src.channels() == 3)
        {
Imgproc.cvtColor(src, gray, Imgproc.COLOR_BGR2GRAY);
        }
        其他
        {
gray = src;
        }
 
        // 显示灰度图像
showWaitDestroy("gray" , gray);

Python

    # 如果源图像不是灰度图，则将其转换为灰度图
    if len(src.shape) != 2
gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
    其他:
gray = src
 
    # 显示灰度图
show_wait_destroy("gray", gray)

将灰度图像转换成二值图像

C++

    // 应用二值化反色阈值，请注意 ~ 符号
    Mat bw;
adaptiveThreshold(~gray, bw, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 15, -2);
 
    // 显示二值图像
show_wait_destroy("binary", bw);

Java

        // 应用自适应阈值在灰度的按位非上
Mat bw = new Mat();
Core.bitwise_not(gray, gray);
Imgproc.adaptiveThreshold(gray, bw, 255, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 15, -2);
 
        // 显示二值图像
showWaitDestroy("binary" , bw);

Python

    ＃在灰度的 not 位上应用自适应阈值，注意 ~ 符号
gray = cv.bitwise_not(gray)
bw = cv.adaptiveThreshold(gray, 255, cv.ADAPTIVE_THRESH_MEAN_C, \
cv.THRESH_BINARY, 15, -2)
    ＃显示二进制图像
show_wait_destroy("binary", bw)

输出图像

现在，我们可以应用形态学操作，以便提取水平线和垂直线，因此可以将音符从乐谱中分离出来，但首先，让我们初始化将为此目的使用的输出图像

C++

    // 创建用于提取水平和垂直线段的图像
    Mat horizontal = bw.clone();
    Mat vertical = bw.clone();

Java

        // 创建用于提取水平和垂直线段的图像
Mat horizontal = bw.clone();
Mat vertical = bw.clone();

Python

    ＃创建用于提取水平线和垂直线的图像
horizontal = np.copy(bw)
vertical = np.copy(bw)

结构元素

正如我们在理论部分中指定的那样，为了提取我们想要的物体，我们需要创建相应的结构元素。由于我们要提取水平线，所以用于此目的的相应结构元素将具有以下形状：

在源代码中，这是通过以下代码段表示的

C++

    // 指定水平轴上的大小
    int horizontal_size = horizontal.cols / 30;
 
    // 创建用于通过形态学运算提取水平线段的结构元素
    Mat horizontalStructure = getStructuringElement(MORPH_RECT, Size(horizontal_size, 1));
 
    // 应用形态学运算
erode(horizontal, horizontal, horizontalStructure, Point(-1, -1));
dilate(horizontal, horizontal, horizontalStructure, Point(-1, -1));
 
    // 显示提取的水平线段
show_wait_destroy("horizontal", horizontal);

Java

        // 指定水平轴上的大小
        int horizontal_size = horizontal.cols() / 30;
 
        // 创建用于通过形态学运算提取水平线段的结构元素
Mat 水平结构 = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(水平大小,1));
 
        // 应用形态学运算
Imgproc.erode(horizontal, horizontal, horizontalStructure);
Imgproc.dilate(horizontal, horizontal, horizontalStructure);
 
        // 显示提取的水平线段
showWaitDestroy("horizontal" , horizontal);

Python

    ＃指定水平轴上的尺寸
cols = horizontal.shape[1]
horizontal_size = cols // 30
 
    ＃通过形态学操作创建用于提取水平线的结构元素
horizontalStructure = cv.getStructuringElement(cv.MORPH_RECT, (horizontal_size, 1))
 
    ＃应用形态学操作
horizontal = cv.erode(horizontal, horizontalStructure)
horizontal = cv.dilate(horizontal, horizontalStructure)
 
    ＃显示提取的水平线
show_wait_destroy("horizontal", horizontal)

垂直线也是如此，其相应的结构元素为：

同样，这表示为

C++

    // 指定垂直轴上的大小
    int vertical_size = vertical.rows / 30;
 
    // 创建用于通过形态学运算提取垂直线段的结构元素
    Mat verticalStructure = getStructuringElement(MORPH_RECT, Size(1, vertical_size));
 
    // 应用形态学运算
erode(vertical, vertical, verticalStructure, Point(-1, -1));
dilate(vertical, vertical, verticalStructure, Point(-1, -1));
 
    // 显示提取的垂直线段
show_wait_destroy("vertical", vertical);

Java

        // 指定垂直轴上的大小
        int vertical_size = vertical.rows() / 30;
 
        // 创建用于通过形态学运算提取垂直线段的结构元素
Mat verticalStructure = Imgproc.getStructuringElement(Imgproc.MORPH_RECT，new Size( 1,vertical_size));
 
        // 应用形态学运算
Imgproc.erode(vertical, vertical, verticalStructure);
Imgproc.dilate(vertical, vertical, verticalStructure);
 
        // 显示提取的垂直线段
showWaitDestroy("vertical", vertical);

Python

    ＃指定垂直轴上的尺寸
rows = vertical.shape[0]
verticalsize = rows // 30
 
    ＃通过形态学操作创建用于提取垂直线的结构元素
verticalStructure = cv.getStructuringElement(cv.MORPH_RECT, (1, verticalsize))
 
    ＃应用形态学操作
vertical = cv.erode(vertical, verticalStructure)
vertical = cv.dilate(vertical, verticalStructure)
 
    ＃显示提取的垂直线
show_wait_destroy("vertical", vertical)

优化边缘/结果

如您所见，我们几乎成功了。然而，此时您会注意到钞票边缘有点粗糙。因此我们需要优化边缘以获得更平滑的结果

C++

    // 反转垂直图像
bitwise_not(vertical, vertical);
show_wait_destroy("vertical_bit", vertical);
 
    // 根据逻辑提取边缘并平滑图像
    // 1. 提取边缘
    // 2. 膨胀（边缘）
    // 3. src.copyTo(平滑)
    // 4. 模糊平滑图像
    // 5. 平滑.copyTo(src，边缘)
 
    // 步骤 1
    Mat edges;
adaptiveThreshold(vertical, edges, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 3, -2);
show_wait_destroy("edges", edges);
 
    // 步骤 2
    Mat 内核 = Mat::ones(2, 2, CV_8UC1);
dilate(边缘, 边缘, 内核);
show_wait_destroy("dilate", 边缘);
 
    // 步骤 3
    Mat 平滑;
垂直.copyTo(平滑);
 
    // 步骤 4
blur(平滑, 平滑, Size(2, 2));
 
    // 步骤 5
平滑.copyTo(垂直, 边缘);
 
    // 显示最终结果
show_wait_destroy("smooth - final", 垂直);

Java

        // 反转垂直图像
Core.bitwise_not(vertical, vertical);
showWaitDestroy("vertical_bit" , vertical);
 
        // 根据逻辑提取边缘并平滑图像
        // 1. 提取边缘
        // 2. 膨胀（边缘）
        // 3. src.copyTo(平滑)
        // 4. 模糊平滑图像
        // 5. 平滑.copyTo(src，边缘)
 
        // 步骤 1
Mat edges = new Mat();
Imgproc.adaptiveThreshold(vertical, edges, 255, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 3, -2);
showWaitDestroy("edges", edges);
 
        // 步骤 2
Mat kernel = Mat.ones(2, 2, CvType.CV_8UC1);
Imgproc.dilate(edges, edges, kernel);
showWaitDestroy("dilate", edges);
 
        // 步骤 3
Mat smooth = new Mat();
vertical.copyTo(smooth);
 
        // 步骤 4
Imgproc.blur(smooth, smooth, new Size(2, 2));
 
        // 步骤 5
smooth.copyTo(vertical, edges);
 
        // 显示最终结果
showWaitDestroy("smooth - final", vertical);

Python

    ＃反转垂直图像
vertical = cv.bitwise_not(vertical)
show_wait_destroy("vertical_bit", vertical)
 
    '''
根据以下逻辑提取边缘并平滑图像
1. 提取边缘
2. 膨胀（边缘）
3. src.copyTo(smooth)
4. 模糊 smooth 图像
5. smooth.copyTo(src, edges)
    '''
 
    ＃步骤 1
edges = cv.adaptiveThreshold(vertical, 255, cv.ADAPTIVE_THRESH_MEAN_C, \
cv.THRESH_BINARY, 3, -2)
show_wait_destroy("edges", edges)
 
    ＃步骤 2
kernel = np.ones((2, 2), np.uint8)
edges = cv.dilate(edges, kernel)
show_wait_destroy("dilate", edges)
 
    ＃步骤 3
smooth = np.copy(vertical)
 
    ＃步骤 4
smooth = cv.blur(smooth, (2, 2))
 
    ＃步骤 5
(行，列) = np.where(边缘不为 0)
垂直[行，列] = 平滑[行，列]
 
    # 展示最终结果
show_wait_destroy("平滑 - 最终结果", 垂直)