モルフォロジー演算による水平線・垂直線の抽出

目次

• 目的
• Theory
  • モルフォロジー演算
  • 構造化要素
• コード
• Explanation / Result
  • 画像の読み込み
  • グレースケール
  • グレースケールから二値画像へ
  • 出力画像
  • 構造要素
  • エッジの精緻化 / 結果

前のチュートリアル: Hit-or-Miss変換
次のチュートリアル: 画像ピラミッド

原著者	Theodore Tsesmelis
互換性	OpenCV >= 3.0

目的

このチュートリアルでは、以下の方法を学ぶ:

• 2つの非常に一般的なモルフォロジー演算子（すなわち膨張と収縮）を、カスタムカーネルの作成とともに適用し、水平軸および垂直軸上の直線を抽出する。この目的のために、以下のOpenCV関数を使用する:

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

  楽譜から音符を抽出することを目標とする例の中で。

理論

モルフォロジー演算

モルフォロジーは、カーネルとしても知られる事前定義された 構造化要素 に基づいて画像を処理する一連の画像処理演算である。出力画像の各ピクセルの値は、入力画像内の対応するピクセルとその近傍との比較に基づいて決まる。カーネルのサイズと形状を選ぶことで、入力画像に対して特定の形状に敏感なモルフォロジー演算を構築できる。

最も基本的なモルフォロジー演算のうちの2つが膨張と収縮である。膨張は画像内のオブジェクトの境界にピクセルを追加し、収縮はちょうどその逆を行う。それぞれ追加または除去されるピクセルの量は、画像を処理するために使用する構造化要素のサイズと形状に依存する。一般に、これら2つの演算が従う規則は以下のとおりである:

• 膨張: 出力ピクセルの値は、構造化要素のサイズと形状の範囲内に入るすべてのピクセルの 最大 値である。例えば二値画像において、カーネルの範囲内に入る入力画像のピクセルのいずれかが値1に設定されていれば、出力画像の対応するピクセルも同様に1に設定される。後者はあらゆる種類の画像（例: グレースケール、bgr など）に当てはまる。

Dilation on a Binary Image

Dilation on a Grayscale Image

• 収縮 (Erosion): 膨張とは逆のことが収縮処理にも当てはまる。出力ピクセルの値は、構造要素のサイズと形状の範囲内に入るすべてのピクセルの最小値となる。下の例の図を参照のこと:

Erosion on a Binary Image

Erosion on a Grayscale Image

構造化要素

上で示したとおり、また一般にあらゆるモルフォロジー演算において、入力画像を走査するために使う構造要素は最も重要な部分である。

構造要素とは、0と1のみからなる行列で、任意の形状とサイズを取り得る。通常は処理対象の画像よりはるかに小さく、値が1のピクセルが近傍を定義する。構造要素の中心ピクセルは原点 (origin) と呼ばれ、着目するピクセル、すなわち処理対象のピクセルを示す。

例えば、次の図は7x7サイズのダイヤモンド形の構造要素を示している。

A Diamond-Shaped Structuring Element and its Origin

構造要素は、直線、ダイヤモンド、円板、周期的な線、円など、多くの一般的な形状やサイズを取り得る。通常は、入力画像内で処理・抽出したい対象と同じサイズ・形状の構造要素を選ぶ。例えば、画像内の線を見つけるには、後で示すように線状の構造要素を作成する。

コード

このチュートリアルのコードを以下に示す。

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]);
 
 // Check if image is loaded fine
 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) {
 // Load the native library.
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
 new Morphology_3Run().run(args);
    }
}

Python

こちらからダウンロードすることもできる。

"""
@file morph_lines_detection.py
@brief Use morphology transformations for extracting horizontal and vertical lines sample code
"""
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)
 
 '''
    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
    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]);
 
 // Check if image is loaded fine
 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)
 
 '''
    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
    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)