Detect Vertical&Horizontal Segments By OpenCV

Detect Vertical&Horizontal Segments By OpenCV，and Save the data to csv.

Steps:

1. Using adaptiveThreshold to generate thresholded image.
2. Using threshold to find lines.
3. Save the data to csv by convert it to json.

 # coding=gbk
 import cv2
 import numpy as np
 import json
 import csv
 import os

 def find_lines(threshold, regions=None, direction='horizontal',
                line_scale=15, iterations=0):
     """Finds horizontal and vertical lines by applying morphological
     transformations on an image.

     Parameters
     ----------
     threshold : object
         numpy.ndarray representing the thresholded image.
     regions : list, optional (default: None)
         List of page regions that may contain tables of the form x1,y1,x2,y2
         where (x1, y1) -> left-top and (x2, y2) -> right-bottom
         in image coordinate space.
     direction : string, optional (default: 'horizontal')
         Specifies whether to find vertical or horizontal lines.
     line_scale : int, optional (default: 15)
         Factor by which the page dimensions will be divided to get
         smallest length of lines that should be detected.

         The larger this value, smaller the detected lines. Making it
         too large will lead to text being detected as lines.
     iterations : int, optional (default: 0)
         Number of times for erosion/dilation is applied.

         For more information, refer `OpenCV's dilate <https://docs.opencv.org/2.4/modules/imgproc/doc/filtering.html#dilate>`_.

     Returns
     -------
     dmask : object
         numpy.ndarray representing pixels where vertical/horizontal
         lines lie.
     lines : list
         List of tuples representing vertical/horizontal lines with
         coordinates relative to a left-top origin in
         image coordinate space.

     """
     lines = []

     if direction == 'vertical':
         size = threshold.shape[0] // line_scale
         el = cv2.getStructuringElement(cv2.MORPH_RECT, (1, size))
     elif direction == 'horizontal':
         size = threshold.shape[1] // line_scale
         el = cv2.getStructuringElement(cv2.MORPH_RECT, (size, 1))
     elif direction is None:
         raise ValueError("Specify direction as either 'vertical' or"
                          " 'horizontal'")

     if regions is not None:
         region_mask = np.zeros(threshold.shape)
         for region in regions:
             x, y, w, h = region
             region_mask[y : y + h, x : x + w] = 1
         threshold = np.multiply(threshold, region_mask)

     threshold = cv2.erode(threshold, el)
     threshold = cv2.dilate(threshold, el)
     dmask = cv2.dilate(threshold, el, iterations=iterations)

     try:
         _, contours, _ = cv2.findContours(
             threshold.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     except ValueError:
         # for opencv backward compatibility
         contours, _ = cv2.findContours(
             threshold.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

     for c in contours:
         x, y, w, h = cv2.boundingRect(c)
         x1, x2 = x, x + w
         y1, y2 = y, y + h
         if direction == 'vertical':
             lines.append(((x1 + x2) // 2, y2, (x1 + x2) // 2, y1))
         elif direction == 'horizontal':
             lines.append((x1, (y1 + y2) // 2, x2, (y1 + y2) // 2))

     return dmask, lines

 def adaptive_threshold(imagename, process_background=False, blocksize=15, c=-2):
     """Thresholds an image using OpenCV's adaptiveThreshold.

     Parameters
     ----------
     imagename : string
         Path to image file.
     process_background : bool, optional (default: False)
         Whether or not to process lines that are in background.
     blocksize : int, optional (default: 15)
         Size of a pixel neighborhood that is used to calculate a
         threshold value for the pixel: 3, 5, 7, and so on.

         For more information, refer `OpenCV's adaptiveThreshold <https://docs.opencv.org/2.4/modules/imgproc/doc/miscellaneous_transformations.html#adaptivethreshold>`_.
     c : int, optional (default: -2)
         Constant subtracted from the mean or weighted mean.
         Normally, it is positive but may be zero or negative as well.

         For more information, refer `OpenCV's adaptiveThreshold <https://docs.opencv.org/2.4/modules/imgproc/doc/miscellaneous_transformations.html#adaptivethreshold>`_.

     Returns
     -------
     img : object
         numpy.ndarray representing the original image.
     threshold : object
         numpy.ndarray representing the thresholded image.

     """
     img = cv2.imread(imagename)
     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

     if process_background:
         threshold = cv2.adaptiveThreshold(
             gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
             cv2.THRESH_BINARY, blocksize, c)
     else:
         threshold = cv2.adaptiveThreshold(
             np.invert(gray), 255,
             cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, blocksize, c)
     return img, threshold

 count = 0
 root = 'E:/VGID_Text/Mycode/linelabel/PDF_JPG/'
 rows=[]
 for root, dirs, files in os.walk(root):
     for img in files:
         if img.endswith('jpg'):
             img_path = root+'/'+img
             image, threshold = adaptive_threshold(img_path)
             find_lines(threshold)
             vertical_mask, vertical_segments = find_lines(threshold, direction='vertical')
             horizontal_mask, horizontal_segments = find_lines(threshold, direction='horizontal')
             lines_list = vertical_segments + horizontal_segments
             objects = []
             lines_dict = {"objects":objects}
             for line in lines_list:
                 point1 = {"x": line[0], "y": line[1]}
                 point2 = {"x": line[2], "y": line[3]}
                 ptList = [point1,point2]
                 polygon = {"ptList":ptList}
                 line_dict ={"polygon":polygon,
                             "name": "line",
                             "type": 4,
                             "color": "#aa40bf",
                             "id": "6173cf75-ea09-4ff4-a75e-5cc99a5ea40e",
                             "cur": 0,
                             "lineStyle": "solid"
                             }
                 objects.append(line_dict)
             lines_json = json.dumps(lines_dict)
             print(count, lines_json)
             row = [img_path, lines_json]
             rows.append(row)
             count = count + 1
 with open('E:/线条标注3k+.csv', 'w', newline='') as csv_file:
     csv_writer = csv.writer(csv_file)
     csv_writer.writerow(['image_path','lines'])
     for row in rows:
         csv_writer.writerow(row)

Reference:Camelot:https://camelot-py.readthedocs.io/en/master/