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

目录

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

上一篇教程： 击中击不中 (Hit-or-Miss)
下一篇教程： 图像金字塔

原作者	Theodore Tsesmelis
兼容性	OpenCV >= 3.0

目标

在本教程中，你将学习如何：

• 通过创建自定义内核，应用两种非常常见的形态学算子（即膨胀和腐蚀），从而提取水平和垂直轴上的直线。为此，你将使用以下 OpenCV 函数：

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

  在本示例中，目标是从乐谱中提取音符。

原理

形态学操作

形态学是一组基于预定义的结构元素（也称为内核）处理图像的图像处理操作。输出图像中每个像素的值取决于输入图像中对应像素及其邻域的比较结果。通过选择内核的大小和形状，可以构建对输入图像中特定形状敏感的形态学操作。

两种最基本的形态学操作是膨胀（dilation）和腐蚀（erosion）。膨胀会增加图像中目标的边界像素，而腐蚀则恰恰相反。添加或移除像素的数量分别取决于用于处理图像的结构元素的大小和形状。通常，这两项操作遵循的规则如下：

• 膨胀 (Dilation)：输出像素的值是结构元素大小和形状范围内所有像素的最大值。例如，在二值图像中，如果内核范围内的输入图像像素中有任何一个值为 1，则输出图像的对应像素也将被设置为 1。后者适用于任何类型的图像（如灰度图、BGR 等）。

二值图像上的膨胀

灰度图像上的膨胀

• 腐蚀 (Erosion)：腐蚀操作则相反。输出像素的值是结构元素大小和形状范围内所有像素的最小值。请看下面的示例图：

二值图像上的腐蚀

灰度图像上的腐蚀

结构元素

如上所述，在任何形态学操作中，用于探测输入图像的结构元素都是最重要的部分。

结构元素是一个仅由 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 | 输入图像}");
    Mat src = imread( samples::findFile( parser.get<String>("@input") ), IMREAD_COLOR);
    if (src.empty())
    {
cout << "无法打开或找到图像！\n" << endl;
cout << "用法: " << argv[0] << " <输入图像>" << endl;
        return -1;
    }
 
    // 显示原图
imshow("src", src);
 
    // 如果源图像不是灰度图，则将其转换为灰度图
    Mat gray;
 
    if (src.channels() == 3)
    {
cvtColor(src, gray, COLOR_BGR2GRAY);
    }
    else
    {
gray = src;
    }
 
    // 显示灰度图
show_wait_destroy("gray", gray);
 
    // 对 gray 的按位取反图应用 adaptiveThreshold，注意 ~ 符号
    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. 膨胀边缘 (dilate)
    // 3. 将原图拷贝到 smooth (src.copyTo)
    // 4. 模糊 smooth 图像
    // 5. 将 smooth 拷贝到 src，以 edges 作为掩码
 
    // 步骤 1
    Mat edges;
adaptiveThreshold(vertical, edges, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 3, -2);
show_wait_destroy("edges", edges);
 
    // 步骤 2
    Mat kernel = Mat::ones(2, 2, CV_8UC1);
dilate(edges, edges, kernel);
show_wait_destroy("dilate", edges);
 
    // 步骤 3
    Mat smooth;
vertical.copyTo(smooth);
 
    // 步骤 4
blur(smooth, smooth, Size(2, 2));
 
    // 步骤 5
smooth.copyTo(vertical, edges);
 
    // 显示最终结果
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

你也可以从此处下载 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("参数不足！");
System.out.println("程序参数：[image_path]");
System.exit(-1);
        }
 
        // 加载图像
Mat src = Imgcodecs.imread(args[0]);
 
        // 检查图像是否加载成功
        if( src.empty() ) {
System.out.println("无法打开图像： " + args[0]);
System.exit(-1);
        }
 
        // 显示原图
HighGui.imshow("src", src);
 
        // 如果源图像不是灰度图，则将其转换为灰度图
Mat gray = new Mat();
 
        if (src.channels() == 3)
        {
Imgproc.cvtColor(src, gray, Imgproc.COLOR_BGR2GRAY);
        }
        else
        {
gray = src;
        }
 
        // 显示灰度图
showWaitDestroy("gray" , gray);
 
        // 对 gray 的按位取反图应用 adaptiveThreshold
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. 膨胀边缘 (dilate)
        // 3. 将原图拷贝到 smooth (src.copyTo)
        // 4. 模糊 smooth 图像
        // 5. 将 smooth 拷贝到 src，以 edges 作为掩码
 
        // 步骤 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

你也可以从此处下载 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 ('参数不足')
        print ('用法：\nmorph_lines_detection.py < 图像路径 >')
        return -1
 
    # 加载图像
src = cv.imread(argv[0], cv.IMREAD_COLOR)
 
    # 检查图像是否加载成功
    if src is None
        print ('打开图像出错： ' + argv[0])
        return -1
 
    # 显示源图像
    cv.imshow("src", src)
    # [load_image]
 
    # [gray]
    # 如果源图像不是灰度图，则将其转换为灰度图
    if len(src.shape) != 2
gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
    else:
gray = src
 
    # 显示灰度图
show_wait_destroy("gray", gray)
    # [gray]
 
    # [bin]
    # 对 gray 的按位取反图应用 adaptiveThreshold，注意 ~ 符号
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)
    # [bin]
 
    # [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. 膨胀边缘 (dilate)
3. 将源图像拷贝到 smooth
4. 模糊 smooth 图像
5. 将 smooth 拷贝到 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
(rows, cols) = np.where(edges != 0)
vertical[rows, cols] = smooth[rows, cols]
 
    # 显示最终结果
show_wait_destroy("smooth - final", vertical)
    # [smooth]
 
    return 0
 
if __name__ == "__main__"
    main(sys.argv[1:])

解释 / 结果

从此处获取图像。

加载图像

C++

    CommandLineParser parser(argc, argv, "{@input | notes.png | 输入图像}");
    Mat src = imread( samples::findFile( parser.get<String>("@input") ), IMREAD_COLOR);
    if (src.empty())
    {
cout << "无法打开或找到图像！\n" << endl;
cout << "用法: " << argv[0] << " <输入图像>" << endl;
        return -1;
    }
 
    // 显示原图
    imshow("src", src);

Java

        // 检查参数数量
        if (args.length == 0){
System.out.println("参数不足！");
System.out.println("程序参数：[image_path]");
System.exit(-1);
        }
 
        // 加载图像
Mat src = Imgcodecs.imread(args[0]);
 
        // 检查图像是否加载成功
        if( src.empty() ) {
System.out.println("无法打开图像： " + args[0]);
System.exit(-1);
        }
 
        // 显示原图
HighGui.imshow("src", src);

Python

    # 检查参数数量
    if len(argv) < 1
        print ('参数不足')
        print ('用法：\nmorph_lines_detection.py < 图像路径 >')
        return -1
 
    # 加载图像
src = cv.imread(argv[0], cv.IMREAD_COLOR)
 
    # 检查图像是否加载成功
    if src is None
        print ('打开图像出错： ' + argv[0])
        return -1
 
    # 显示源图像
    cv.imshow("src", src)

灰度化

C++

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

Java

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

Python

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

灰度图转二值图像

C++

    // 对 gray 的按位取反图应用 adaptiveThreshold，注意 ~ 符号
    Mat bw;
    adaptiveThreshold(~gray, bw, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 15, -2);
 
    // 显示二值图像
show_wait_destroy("binary", bw);

Java

        // 对 gray 的按位取反图应用 adaptiveThreshold
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

    # 对 gray 的按位取反图应用 adaptiveThreshold，注意 ~ 符号
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 horizontalStructure = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(horizontal_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. 膨胀边缘 (dilate)
    // 3. 将原图拷贝到 smooth (src.copyTo)
    // 4. 模糊 smooth 图像
    // 5. 将 smooth 拷贝到 src，以 edges 作为掩码
 
    // 步骤 1
    Mat edges;
    adaptiveThreshold(vertical, edges, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 3, -2);
show_wait_destroy("edges", edges);
 
    // 步骤 2
    Mat kernel = Mat::ones(2, 2, CV_8UC1);
    dilate(edges, edges, kernel);
show_wait_destroy("dilate", edges);
 
    // 步骤 3
    Mat smooth;
vertical.copyTo(smooth);
 
    // 步骤 4
    blur(smooth, smooth, Size(2, 2));
 
    // 步骤 5
smooth.copyTo(vertical, edges);
 
    // 显示最终结果
show_wait_destroy("smooth - final", vertical);

Java

        // 反转垂直图像
Core.bitwise_not(vertical, vertical);
showWaitDestroy("vertical_bit" , vertical);
 
        // 根据逻辑提取边缘并平滑图像
        // 1. 提取边缘
        // 2. 膨胀边缘 (dilate)
        // 3. 将原图拷贝到 smooth (src.copyTo)
        // 4. 模糊 smooth 图像
        // 5. 将 smooth 拷贝到 src，以 edges 作为掩码
 
        // 步骤 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. 膨胀边缘 (dilate)
3. 将源图像拷贝到 smooth
4. 模糊 smooth 图像
5. 将 smooth 拷贝到 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
(rows, cols) = np.where(edges != 0)
vertical[rows, cols] = smooth[rows, cols]
 
    # 显示最终结果
show_wait_destroy("smooth - final", vertical)