pep 8 code style

src/eynollah/cli.py

@@ -182,7 +182,7 @@ def main(
     if textline_light and not light_version:
         print('Error: You used -tll to enable light textline detection but -light is not enabled')
         sys.exit(1)
-    if extract_only_images and  (allow_enhancement or allow_scaling or light_version or curved_line or textline_light or full_layout or tables or right2left or headers_off) :
+    if extract_only_images and (allow_enhancement or allow_scaling or light_version or curved_line or textline_light or full_layout or tables or right2left or headers_off):
         print('Error: You used -eoi which can not be enabled alongside light_version -light or allow_scaling -as or allow_enhancement -ae or curved_line -cl or textline_light -tll or full_layout -fl or tables -tab or right2left -r2l or headers_off -ho')
         sys.exit(1)
     eynollah = Eynollah(
@@ -215,5 +215,6 @@ def main(
         pcgts = eynollah.run()
         eynollah.writer.write_pagexml(pcgts)
 
+
 if __name__ == "__main__":
     main()

src/eynollah/ocrd_cli.py

@@ -2,10 +2,12 @@ from .processor import EynollahProcessor
 from click import command
 from ocrd.decorators import ocrd_cli_options, ocrd_cli_wrap_processor
 
+
 @command()
 @ocrd_cli_options
 def main(*args, **kwargs):
     return ocrd_cli_wrap_processor(EynollahProcessor, *args, **kwargs)
 
+
 if __name__ == '__main__':
     main()

src/eynollah/plot.py

@@ -9,6 +9,7 @@ from .utils import crop_image_inside_box
 from .utils.rotate import rotate_image_different
 from .utils.resize import resize_image
 
+
 class EynollahPlotter():
     """
     Class collecting all the plotting and image writing methods
@@ -44,7 +45,7 @@ class EynollahPlotter():
         if self.dir_of_layout is not None:
             values = np.unique(text_regions_p[:, :])
             # pixels=['Background' , 'Main text' , 'Heading' , 'Marginalia' ,'Drop capitals' , 'Images' , 'Seperators' , 'Tables', 'Graphics']
-            pixels=['Background' , 'Main text'  , 'Image' , 'Separator','Marginalia']
+            pixels = ['Background', 'Main text', 'Image', 'Separator', 'Marginalia']
             values_indexes = [0, 1, 2, 3, 4]
             plt.figure(figsize=(40, 40))
             plt.rcParams["font.size"] = "40"
@@ -54,12 +55,11 @@ class EynollahPlotter():
             plt.legend(handles=patches, bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.0, fontsize=40)
             plt.savefig(os.path.join(self.dir_of_layout, self.image_filename_stem + "_layout_main.png"))
 
-
     def save_plot_of_layout_main_all(self, text_regions_p, image_page):
         if self.dir_of_all is not None:
             values = np.unique(text_regions_p[:, :])
-            # pixels=['Background' , 'Main text' , 'Heading' , 'Marginalia' ,'Drop capitals' , 'Images' , 'Seperators' , 'Tables', 'Graphics']
-            pixels=['Background' , 'Main text'  , 'Image' , 'Separator','Marginalia']
+            # pixels = ['Background', 'Main text', 'Heading', 'Marginalia', 'Drop capitals', 'Images', 'Seperators', 'Tables', 'Graphics']
+            pixels = ['Background', 'Main text', 'Image', 'Separator', 'Marginalia']
             values_indexes = [0, 1, 2, 3, 4]
             plt.figure(figsize=(80, 40))
             plt.rcParams["font.size"] = "40"
@@ -131,33 +131,34 @@ class EynollahPlotter():
             cv2.imwrite(os.path.join(self.dir_of_all, self.image_filename_stem + "_page.png"), image_page)
         if self.dir_save_page is not None:
             cv2.imwrite(os.path.join(self.dir_save_page, self.image_filename_stem + "_page.png"), image_page)
+
     def save_enhanced_image(self, img_res):
         cv2.imwrite(os.path.join(self.dir_out, self.image_filename_stem + "_enhanced.png"), img_res)
 
     def save_plot_of_textline_density(self, img_patch_org):
         if self.dir_of_all is not None:
-            plt.figure(figsize=(80,40))
-            plt.rcParams['font.size']='50'
-            plt.subplot(1,2,1)
+            plt.figure(figsize=(80, 40))
+            plt.rcParams['font.size'] = '50'
+            plt.subplot(1, 2, 1)
             plt.imshow(img_patch_org)
-            plt.subplot(1,2,2)
-            plt.plot(gaussian_filter1d(img_patch_org.sum(axis=1), 3),np.array(range(len(gaussian_filter1d(img_patch_org.sum(axis=1), 3)))),linewidth=8)
-            plt.xlabel('Density of textline prediction in direction of X axis',fontsize=60)
-            plt.ylabel('Height',fontsize=60)
-            plt.yticks([0,len(gaussian_filter1d(img_patch_org.sum(axis=1), 3))])
+            plt.subplot(1, 2, 2)
+            plt.plot(gaussian_filter1d(img_patch_org.sum(axis=1), 3), np.array(range(len(gaussian_filter1d(img_patch_org.sum(axis=1), 3)))), linewidth=8)
+            plt.xlabel('Density of textline prediction in direction of X axis', fontsize=60)
+            plt.ylabel('Height', fontsize=60)
+            plt.yticks([0, len(gaussian_filter1d(img_patch_org.sum(axis=1), 3))])
             plt.gca().invert_yaxis()
-            plt.savefig(os.path.join(self.dir_of_all, self.image_filename_stem+'_density_of_textline.png'))
+            plt.savefig(os.path.join(self.dir_of_all, self.image_filename_stem + '_density_of_textline.png'))
 
     def save_plot_of_rotation_angle(self, angels, var_res):
         if self.dir_of_all is not None:
-            plt.figure(figsize=(60,30))
-            plt.rcParams['font.size']='50'
-            plt.plot(angels,np.array(var_res),'-o',markersize=25,linewidth=4)
-            plt.xlabel('angle',fontsize=50)
-            plt.ylabel('variance of sum of rotated textline in direction of x axis',fontsize=50)
-            plt.plot(angels[np.argmax(var_res)],var_res[np.argmax(np.array(var_res))]  ,'*',markersize=50,label='Angle of deskewing=' +str("{:.2f}".format(angels[np.argmax(var_res)]))+r'$\degree$')
+            plt.figure(figsize=(60, 30))
+            plt.rcParams['font.size'] = '50'
+            plt.plot(angels, np.array(var_res), '-o', markersize=25, linewidth=4)
+            plt.xlabel('angle', fontsize=50)
+            plt.ylabel('variance of sum of rotated textline in direction of x axis', fontsize=50)
+            plt.plot(angels[np.argmax(var_res)], var_res[np.argmax(np.array(var_res))], '*', markersize=50, label='Angle of deskewing=' + str("{:.2f}".format(angels[np.argmax(var_res)])) + r'$\degree$')
             plt.legend(loc='best')
-            plt.savefig(os.path.join(self.dir_of_all, self.image_filename_stem+'_rotation_angle.png'))
+            plt.savefig(os.path.join(self.dir_of_all, self.image_filename_stem + '_rotation_angle.png'))
 
     def write_images_into_directory(self, img_contours, image_page):
         if self.dir_of_cropped_images is not None:
@@ -165,11 +166,10 @@ class EynollahPlotter():
             for cont_ind in img_contours:
                 x, y, w, h = cv2.boundingRect(cont_ind)
                 box = [x, y, w, h]
-                croped_page, page_coord = crop_image_inside_box(box, image_page)
+                cropped_page, page_coord = crop_image_inside_box(box, image_page)
 
-                croped_page = resize_image(croped_page, int(croped_page.shape[0] / self.scale_y), int(croped_page.shape[1] / self.scale_x))
+                cropped_page = resize_image(cropped_page, int(cropped_page.shape[0] / self.scale_y), int(cropped_page.shape[1] / self.scale_x))
 
                 path = os.path.join(self.dir_of_cropped_images, self.image_filename_stem + "_" + str(index) + ".jpg")
-                cv2.imwrite(path, croped_page)
+                cv2.imwrite(path, cropped_page)
                 index += 1
-

src/eynollah/processor.py

@@ -22,6 +22,7 @@ from .utils.pil_cv2 import pil2cv
 
 OCRD_TOOL = loads(resource_string(__name__, 'ocrd-tool.json').decode('utf8'))
 
+
 class EynollahProcessor(Processor):
 
     def __init__(self, *args, **kwargs):

src/eynollah/utils/contour.py

@@ -5,6 +5,8 @@ from shapely import geometry
 from .rotate import rotate_image, rotation_image_new
 from multiprocessing import Process, Queue, cpu_count
 from multiprocessing import Pool
+
+
 def contours_in_same_horizon(cy_main_hor):
     X1 = np.zeros((len(cy_main_hor), len(cy_main_hor)))
     X2 = np.zeros((len(cy_main_hor), len(cy_main_hor)))
@@ -22,6 +24,7 @@ def contours_in_same_horizon(cy_main_hor):
             all_args.append(list(set(list_h)))
     return np.unique(np.array(all_args, dtype=object))
 
+
 def find_contours_mean_y_diff(contours_main):
     M_main = [cv2.moments(contours_main[j]) for j in range(len(contours_main))]
     cy_main = [(M_main[j]["m01"] / (M_main[j]["m00"] + 1e-32)) for j in range(len(M_main))]
@@ -29,7 +32,6 @@ def find_contours_mean_y_diff(contours_main):
 
 
 def get_text_region_boxes_by_given_contours(contours):
-
     kernel = np.ones((5, 5), np.uint8)
     boxes = []
     contours_new = []
@@ -42,39 +44,43 @@ def get_text_region_boxes_by_given_contours(contours):
     del contours
     return boxes, contours_new
 
+
 def filter_contours_area_of_image(image, contours, hierarchy, max_area, min_area):
     found_polygons_early = list()
 
-    for jv,c in enumerate(contours):
+    for jv, c in enumerate(contours):
         if len(c) < 3:  # A polygon cannot have less than 3 points
             continue
 
         polygon = geometry.Polygon([point[0] for point in c])
         area = polygon.area
-        if area >= min_area * np.prod(image.shape[:2]) and area <= max_area * np.prod(image.shape[:2]) and hierarchy[0][jv][3] == -1:  # and hierarchy[0][jv][3]==-1 :
+        if area >= min_area * np.prod(image.shape[:2]) and area <= max_area * np.prod(image.shape[:2]) and \
+                hierarchy[0][jv][3] == -1:  # and hierarchy[0][jv][3]==-1 :
             found_polygons_early.append(np.array([[point] for point in polygon.exterior.coords], dtype=np.uint))
     return found_polygons_early
 
+
 def filter_contours_area_of_image_tables(image, contours, hierarchy, max_area, min_area):
     found_polygons_early = list()
 
-    for jv,c in enumerate(contours):
+    for jv, c in enumerate(contours):
         if len(c) < 3:  # A polygon cannot have less than 3 points
             continue
 
         polygon = geometry.Polygon([point[0] for point in c])
         # area = cv2.contourArea(c)
         area = polygon.area
-        ##print(np.prod(thresh.shape[:2]))
+        # print(np.prod(thresh.shape[:2]))
         # Check that polygon has area greater than minimal area
         # print(hierarchy[0][jv][3],hierarchy )
-        if area >= min_area * np.prod(image.shape[:2]) and area <= max_area * np.prod(image.shape[:2]):  # and hierarchy[0][jv][3]==-1 :
+        if area >= min_area * np.prod(image.shape[:2]) and area <= max_area * np.prod(
+                image.shape[:2]):  # and hierarchy[0][jv][3]==-1 :
             # print(c[0][0][1])
             found_polygons_early.append(np.array([[point] for point in polygon.exterior.coords], dtype=np.int32))
     return found_polygons_early
 
-def find_new_features_of_contours(contours_main):
 
+def find_new_features_of_contours(contours_main):
     areas_main = np.array([cv2.contourArea(contours_main[j]) for j in range(len(contours_main))])
     M_main = [cv2.moments(contours_main[j]) for j in range(len(contours_main))]
     cx_main = [(M_main[j]["m10"] / (M_main[j]["m00"] + 1e-32)) for j in range(len(M_main))]
@@ -85,7 +91,8 @@ def find_new_features_of_contours(contours_main):
         argmin_x_main = np.array([np.argmin(contours_main[j][:, 0, 0]) for j in range(len(contours_main))])
 
         x_min_from_argmin = np.array([contours_main[j][argmin_x_main[j], 0, 0] for j in range(len(contours_main))])
-        y_corr_x_min_from_argmin = np.array([contours_main[j][argmin_x_main[j], 0, 1] for j in range(len(contours_main))])
+        y_corr_x_min_from_argmin = np.array(
+            [contours_main[j][argmin_x_main[j], 0, 1] for j in range(len(contours_main))])
 
         x_max_main = np.array([np.max(contours_main[j][:, 0, 0]) for j in range(len(contours_main))])
 
@@ -107,27 +114,28 @@ def find_new_features_of_contours(contours_main):
     # dis_x=np.abs(x_max_main-x_min_main)
 
     return cx_main, cy_main, x_min_main, x_max_main, y_min_main, y_max_main, y_corr_x_min_from_argmin
-def find_features_of_contours(contours_main):
 
 
-    areas_main=np.array([cv2.contourArea(contours_main[j]) for j in range(len(contours_main))])
-    M_main=[cv2.moments(contours_main[j]) for j in range(len(contours_main))]
-    cx_main=[(M_main[j]['m10']/(M_main[j]['m00']+1e-32)) for j in range(len(M_main))]
-    cy_main=[(M_main[j]['m01']/(M_main[j]['m00']+1e-32)) for j in range(len(M_main))]
-    x_min_main=np.array([np.min(contours_main[j][:,0,0]) for j in range(len(contours_main))])
-    x_max_main=np.array([np.max(contours_main[j][:,0,0]) for j in range(len(contours_main))])
-
-    y_min_main=np.array([np.min(contours_main[j][:,0,1]) for j in range(len(contours_main))])
-    y_max_main=np.array([np.max(contours_main[j][:,0,1]) for j in range(len(contours_main))])
+def find_features_of_contours(contours_main):
+    areas_main = np.array([cv2.contourArea(contours_main[j]) for j in range(len(contours_main))])
+    M_main = [cv2.moments(contours_main[j]) for j in range(len(contours_main))]
+    cx_main = [(M_main[j]['m10'] / (M_main[j]['m00'] + 1e-32)) for j in range(len(M_main))]
+    cy_main = [(M_main[j]['m01'] / (M_main[j]['m00'] + 1e-32)) for j in range(len(M_main))]
+    x_min_main = np.array([np.min(contours_main[j][:, 0, 0]) for j in range(len(contours_main))])
+    x_max_main = np.array([np.max(contours_main[j][:, 0, 0]) for j in range(len(contours_main))])
 
+    y_min_main = np.array([np.min(contours_main[j][:, 0, 1]) for j in range(len(contours_main))])
+    y_max_main = np.array([np.max(contours_main[j][:, 0, 1]) for j in range(len(contours_main))])
 
     return y_min_main, y_max_main
+
+
 def return_parent_contours(contours, hierarchy):
     contours_parent = [contours[i] for i in range(len(contours)) if hierarchy[0][i][3] == -1]
     return contours_parent
 
-def return_contours_of_interested_region(region_pre_p, pixel, min_area=0.0002):
 
+def return_contours_of_interested_region(region_pre_p, pixel, min_area=0.0002):
     # pixels of images are identified by 5
     if len(region_pre_p.shape) == 3:
         cnts_images = (region_pre_p[:, :, 0] == pixel) * 1
@@ -145,6 +153,7 @@ def return_contours_of_interested_region(region_pre_p, pixel, min_area=0.0002):
 
     return contours_imgs
 
+
 def do_work_of_contours_in_image(queue_of_all_params, contours_per_process, indexes_r_con_per_pro, img, slope_first):
     cnts_org_per_each_subprocess = []
     index_by_text_region_contours = []
@@ -165,14 +174,12 @@ def do_work_of_contours_in_image(queue_of_all_params, contours_per_process, inde
         cont_int[0][:, 0, 0] = cont_int[0][:, 0, 0] + np.abs(img_copy.shape[1] - img.shape[1])
         cont_int[0][:, 0, 1] = cont_int[0][:, 0, 1] + np.abs(img_copy.shape[0] - img.shape[0])
 
-
         cnts_org_per_each_subprocess.append(cont_int[0])
 
-    queue_of_all_params.put([ cnts_org_per_each_subprocess, index_by_text_region_contours])
+    queue_of_all_params.put([cnts_org_per_each_subprocess, index_by_text_region_contours])
 
 
 def get_textregion_contours_in_org_image_multi(cnts, img, slope_first):
-    
     num_cores = cpu_count()
     queue_of_all_params = Queue()
 
@@ -180,10 +187,10 @@ def get_textregion_contours_in_org_image_multi(cnts, img, slope_first):
     nh = np.linspace(0, len(cnts), num_cores + 1)
     indexes_by_text_con = np.array(range(len(cnts)))
     for i in range(num_cores):
-        contours_per_process = cnts[int(nh[i]) : int(nh[i + 1])]
-        indexes_text_con_per_process = indexes_by_text_con[int(nh[i]) : int(nh[i + 1])]
+        contours_per_process = cnts[int(nh[i]): int(nh[i + 1])]
+        indexes_text_con_per_process = indexes_by_text_con[int(nh[i]): int(nh[i + 1])]
 
-        processes.append(Process(target=do_work_of_contours_in_image, args=(queue_of_all_params, contours_per_process, indexes_text_con_per_process, img,slope_first )))
+        processes.append(Process(target=do_work_of_contours_in_image, args=(queue_of_all_params, contours_per_process, indexes_text_con_per_process, img, slope_first)))
     for i in range(num_cores):
         processes[i].start()
     cnts_org = []
@@ -200,7 +207,9 @@ def get_textregion_contours_in_org_image_multi(cnts, img, slope_first):
 
     print(all_index_text_con)
     return cnts_org
-def loop_contour_image(index_l, cnts,img, slope_first):
+
+
+def loop_contour_image(index_l, cnts, img, slope_first):
     img_copy = np.zeros(img.shape)
     img_copy = cv2.fillPoly(img_copy, pts=[cnts[index_l]], color=(1, 1, 1))
 
@@ -209,7 +218,7 @@ def loop_contour_image(index_l, cnts,img, slope_first):
 
     # print(img.shape,'img')
     img_copy = rotation_image_new(img_copy, -slope_first)
-    ##print(img_copy.shape,'img_copy')
+    # print(img_copy.shape,'img_copy')
     # plt.imshow(img_copy)
     # plt.show()
 
@@ -224,17 +233,17 @@ def loop_contour_image(index_l, cnts,img, slope_first):
     # print(np.shape(cont_int[0]))
     return cont_int[0]
 
-def get_textregion_contours_in_org_image_multi2(cnts, img, slope_first):
 
+def get_textregion_contours_in_org_image_multi2(cnts, img, slope_first):
     cnts_org = []
     # print(cnts,'cnts')
     with Pool(cpu_count()) as p:
-        cnts_org = p.starmap(loop_contour_image, [(index_l,cnts, img,slope_first) for index_l in range(len(cnts))])
+        cnts_org = p.starmap(loop_contour_image, [(index_l, cnts, img, slope_first) for index_l in range(len(cnts))])
 
     return cnts_org
 
-def get_textregion_contours_in_org_image(cnts, img, slope_first):
 
+def get_textregion_contours_in_org_image(cnts, img, slope_first):
     cnts_org = []
     # print(cnts,'cnts')
     for i in range(len(cnts)):
@@ -246,7 +255,7 @@ def get_textregion_contours_in_org_image(cnts, img, slope_first):
 
         # print(img.shape,'img')
         img_copy = rotation_image_new(img_copy, -slope_first)
-        ##print(img_copy.shape,'img_copy')
+        # print(img_copy.shape,'img_copy')
         # plt.imshow(img_copy)
         # plt.show()
 
@@ -263,17 +272,17 @@ def get_textregion_contours_in_org_image(cnts, img, slope_first):
 
     return cnts_org
 
-def get_textregion_contours_in_org_image_light(cnts, img, slope_first):
 
+def get_textregion_contours_in_org_image_light(cnts, img, slope_first):
     h_o = img.shape[0]
     w_o = img.shape[1]
 
-    img = cv2.resize(img, (int(img.shape[1]/3.), int(img.shape[0]/3.)), interpolation=cv2.INTER_NEAREST)
-    ##cnts = list( (np.array(cnts)/2).astype(np.int16) )
-    #cnts = cnts/2
-    cnts = [(i/ 3).astype(np.int32) for i in cnts]
+    img = cv2.resize(img, (int(img.shape[1] / 3.), int(img.shape[0] / 3.)), interpolation=cv2.INTER_NEAREST)
+    # cnts = list( (np.array(cnts)/2).astype(np.int16) )
+    # cnts = cnts/2
+    cnts = [(i / 3).astype(np.int32) for i in cnts]
     cnts_org = []
-    #print(cnts,'cnts')
+    # print(cnts,'cnts')
     for i in range(len(cnts)):
         img_copy = np.zeros(img.shape)
         img_copy = cv2.fillPoly(img_copy, pts=[cnts[i]], color=(1, 1, 1))
@@ -283,7 +292,7 @@ def get_textregion_contours_in_org_image_light(cnts, img, slope_first):
 
         # print(img.shape,'img')
         img_copy = rotation_image_new(img_copy, -slope_first)
-        ##print(img_copy.shape,'img_copy')
+        # print(img_copy.shape,'img_copy')
         # plt.imshow(img_copy)
         # plt.show()
 
@@ -296,12 +305,12 @@ def get_textregion_contours_in_org_image_light(cnts, img, slope_first):
         cont_int[0][:, 0, 0] = cont_int[0][:, 0, 0] + np.abs(img_copy.shape[1] - img.shape[1])
         cont_int[0][:, 0, 1] = cont_int[0][:, 0, 1] + np.abs(img_copy.shape[0] - img.shape[0])
         # print(np.shape(cont_int[0]))
-        cnts_org.append(cont_int[0]*3)
+        cnts_org.append(cont_int[0] * 3)
 
     return cnts_org
 
-def return_contours_of_interested_textline(region_pre_p, pixel):
 
+def return_contours_of_interested_textline(region_pre_p, pixel):
     # pixels of images are identified by 5
     if len(region_pre_p.shape) == 3:
         cnts_images = (region_pre_p[:, :, 0] == pixel) * 1
@@ -317,8 +326,8 @@ def return_contours_of_interested_textline(region_pre_p, pixel):
     contours_imgs = filter_contours_area_of_image_tables(thresh, contours_imgs, hierarchy, max_area=1, min_area=0.000000003)
     return contours_imgs
 
-def return_contours_of_image(image):
 
+def return_contours_of_image(image):
     if len(image.shape) == 2:
         image = np.repeat(image[:, :, np.newaxis], 3, axis=2)
         image = image.astype(np.uint8)
@@ -329,8 +338,8 @@ def return_contours_of_image(image):
     contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
     return contours, hierarchy
 
-def return_contours_of_interested_region_by_min_size(region_pre_p, pixel, min_size=0.00003):
 
+def return_contours_of_interested_region_by_min_size(region_pre_p, pixel, min_size=0.00003):
     # pixels of images are identified by 5
     if len(region_pre_p.shape) == 3:
         cnts_images = (region_pre_p[:, :, 0] == pixel) * 1
@@ -348,8 +357,8 @@ def return_contours_of_interested_region_by_min_size(region_pre_p, pixel, min_si
 
     return contours_imgs
 
-def return_contours_of_interested_region_by_size(region_pre_p, pixel, min_area, max_area):
 
+def return_contours_of_interested_region_by_size(region_pre_p, pixel, min_area, max_area):
     # pixels of images are identified by 5
     if len(region_pre_p.shape) == 3:
         cnts_images = (region_pre_p[:, :, 0] == pixel) * 1
@@ -367,4 +376,3 @@ def return_contours_of_interested_region_by_size(region_pre_p, pixel, min_area,
     img_ret = np.zeros((region_pre_p.shape[0], region_pre_p.shape[1], 3))
     img_ret = cv2.fillPoly(img_ret, pts=contours_imgs, color=(1, 1, 1))
     return img_ret[:, :, 0]
-

src/eynollah/utils/counter.py

@@ -3,6 +3,7 @@ from collections import Counter
 REGION_ID_TEMPLATE = 'region_%04d'
 LINE_ID_TEMPLATE = 'region_%04d_line_%04d'
 
+
 class EynollahIdCounter():
 
     def __init__(self, region_idx=0, line_idx=0):

src/eynollah/utils/drop_capitals.py

@@ -6,6 +6,7 @@ from .contour import (
     return_parent_contours,
 )
 
+
 def adhere_drop_capital_region_into_corresponding_textline(
     text_regions_p,
     polygons_of_drop_capitals,
@@ -26,8 +27,8 @@ def adhere_drop_capital_region_into_corresponding_textline(
 
     img_con_all = np.zeros((text_regions_p.shape[0], text_regions_p.shape[1], 3))
     for j_cont in range(len(contours_only_text_parent)):
-        img_con_all[all_box_coord[j_cont][0] : all_box_coord[j_cont][1], all_box_coord[j_cont][2] : all_box_coord[j_cont][3], 0] = (j_cont + 1) * 3
-        # img_con_all=cv2.fillPoly(img_con_all,pts=[contours_only_text_parent[j_cont]],color=((j_cont+1)*3,(j_cont+1)*3,(j_cont+1)*3))
+        img_con_all[all_box_coord[j_cont][0]: all_box_coord[j_cont][1], all_box_coord[j_cont][2]: all_box_coord[j_cont][3], 0] = (j_cont + 1) * 3
+        # img_con_all=cv2.fillPoly(img_con_all,pts = [contours_only_text_parent[j_cont]],color = ((j_cont+1)*3,(j_cont+1)*3,(j_cont+1)*3))
 
     # plt.imshow(img_con_all[:,:,0])
     # plt.show()
@@ -44,7 +45,7 @@ def adhere_drop_capital_region_into_corresponding_textline(
 
         # plt.imshow(img_con[:,:,0])
         # plt.show()
-        ##img_con=cv2.dilate(img_con, kernel, iterations=30)
+        # img_con=cv2.dilate(img_con, kernel, iterations=30)
 
         # plt.imshow(img_con[:,:,0])
         # plt.show()
@@ -185,7 +186,7 @@ def adhere_drop_capital_region_into_corresponding_textline(
                     # contours_biggest[:,0,1]=contours_biggest[:,0,1]#-all_box_coord[int(region_final)][0]
                     # print(np.shape(contours_biggest),'contours_biggest')
                     # print(np.shape(all_found_textline_polygons[int(region_final)][arg_min]))
-                    ##contours_biggest=contours_biggest.reshape(np.shape(contours_biggest)[0],np.shape(contours_biggest)[2])
+                    # contours_biggest=contours_biggest.reshape(np.shape(contours_biggest)[0],np.shape(contours_biggest)[2])
                     all_found_textline_polygons[int(region_final)][arg_min] = contours_biggest
                 except:
                     pass
@@ -230,7 +231,7 @@ def adhere_drop_capital_region_into_corresponding_textline(
                     contours_biggest[:, 0, 0] = contours_biggest[:, 0, 0]  # -all_box_coord[int(region_final)][2]
                     contours_biggest[:, 0, 1] = contours_biggest[:, 0, 1]  # -all_box_coord[int(region_final)][0]
 
-                    ##contours_biggest=contours_biggest.reshape(np.shape(contours_biggest)[0],np.shape(contours_biggest)[2])
+                    # contours_biggest=contours_biggest.reshape(np.shape(contours_biggest)[0],np.shape(contours_biggest)[2])
                     all_found_textline_polygons[int(region_final)][arg_min] = contours_biggest
                     # all_found_textline_polygons[int(region_final)][arg_min]=contours_biggest
 
@@ -239,49 +240,49 @@ def adhere_drop_capital_region_into_corresponding_textline(
             else:
                 pass
 
-            ##cx_t,cy_t ,_, _, _ ,_,_= find_new_features_of_contours(all_found_textline_polygons[int(region_final)])
-            ###print(all_box_coord[j_cont])
-            ###print(cx_t)
-            ###print(cy_t)
-            ###print(cx_d[i_drop])
-            ###print(cy_d[i_drop])
-            ##y_lines=all_box_coord[int(region_final)][0]+np.array(cy_t)
+            # cx_t,cy_t ,_, _, _ ,_,_ = find_new_features_of_contours(all_found_textline_polygons[int(region_final)])
+            # print(all_box_coord[j_cont])
+            # print(cx_t)
+            # print(cy_t)
+            # print(cx_d[i_drop])
+            # print(cy_d[i_drop])
+            # y_lines = all_box_coord[int(region_final)][0]+np.array(cy_t)
 
-            ##y_lines[y_lines<y_min_d[i_drop]]=0
-            ###print(y_lines)
+            # y_lines[y_lines<y_min_d[i_drop]]=0
+            # print(y_lines)
 
-            ##arg_min=np.argmin(np.abs(y_lines-y_min_d[i_drop])  )
-            ###print(arg_min)
+            # arg_min=np.argmin(np.abs(y_lines-y_min_d[i_drop])  )
+            # print(arg_min)
 
-            ##cnt_nearest=np.copy(all_found_textline_polygons[int(region_final)][arg_min])
-            ##cnt_nearest[:,0,0]=all_found_textline_polygons[int(region_final)][arg_min][:,0,0]#+all_box_coord[int(region_final)][2]
-            ##cnt_nearest[:,0,1]=all_found_textline_polygons[int(region_final)][arg_min][:,0,1]#+all_box_coord[int(region_final)][0]
+            # cnt_nearest=np.copy(all_found_textline_polygons[int(region_final)][arg_min])
+            # cnt_nearest[:,0,0]=all_found_textline_polygons[int(region_final)][arg_min][:,0,0]#+all_box_coord[int(region_final)][2]
+            # cnt_nearest[:,0,1]=all_found_textline_polygons[int(region_final)][arg_min][:,0,1]#+all_box_coord[int(region_final)][0]
 
-            ##img_textlines=np.zeros((text_regions_p.shape[0],text_regions_p.shape[1],3))
-            ##img_textlines=cv2.fillPoly(img_textlines,pts=[cnt_nearest],color=(255,255,255))
-            ##img_textlines=cv2.fillPoly(img_textlines,pts=[polygons_of_drop_capitals[i_drop] ],color=(255,255,255))
+            # img_textlines=np.zeros((text_regions_p.shape[0],text_regions_p.shape[1],3))
+            # img_textlines=cv2.fillPoly(img_textlines,pts=[cnt_nearest],color=(255,255,255))
+            # img_textlines=cv2.fillPoly(img_textlines,pts=[polygons_of_drop_capitals[i_drop] ],color=(255,255,255))
 
-            ##img_textlines=img_textlines.astype(np.uint8)
+            # img_textlines=img_textlines.astype(np.uint8)
 
-            ##plt.imshow(img_textlines)
-            ##plt.show()
-            ##imgray = cv2.cvtColor(img_textlines, cv2.COLOR_BGR2GRAY)
-            ##ret, thresh = cv2.threshold(imgray, 0, 255, 0)
+            # plt.imshow(img_textlines)
+            # plt.show()
+            # imgray = cv2.cvtColor(img_textlines, cv2.COLOR_BGR2GRAY)
+            # ret, thresh = cv2.threshold(imgray, 0, 255, 0)
 
-            ##contours_combined,hierarchy=cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
+            # contours_combined,hierarchy=cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
 
-            ##print(len(contours_combined),'len textlines mixed')
-            ##areas_cnt_text=np.array([cv2.contourArea(contours_combined[j]) for j in range(len(contours_combined))])
+            # print(len(contours_combined),'len textlines mixed')
+            # areas_cnt_text=np.array([cv2.contourArea(contours_combined[j]) for j in range(len(contours_combined))])
 
-            ##contours_biggest=contours_combined[np.argmax(areas_cnt_text)]
+            # contours_biggest=contours_combined[np.argmax(areas_cnt_text)]
 
-            ###print(np.shape(contours_biggest))
-            ###print(contours_biggest[:])
-            ##contours_biggest[:,0,0]=contours_biggest[:,0,0]#-all_box_coord[int(region_final)][2]
-            ##contours_biggest[:,0,1]=contours_biggest[:,0,1]#-all_box_coord[int(region_final)][0]
+            # rint(np.shape(contours_biggest))
+            # print(contours_biggest[:])
+            # contours_biggest[:,0,0]=contours_biggest[:,0,0]#-all_box_coord[int(region_final)][2]
+            # contours_biggest[:,0,1]=contours_biggest[:,0,1]#-all_box_coord[int(region_final)][0]
 
-            ##contours_biggest=contours_biggest.reshape(np.shape(contours_biggest)[0],np.shape(contours_biggest)[2])
-            ##all_found_textline_polygons[int(region_final)][arg_min]=contours_biggest
+            # contours_biggest=contours_biggest.reshape(np.shape(contours_biggest)[0],np.shape(contours_biggest)[2])
+            # all_found_textline_polygons[int(region_final)][arg_min]=contours_biggest
 
         else:
             if len(region_with_intersected_drop) > 1:
@@ -399,71 +400,72 @@ def adhere_drop_capital_region_into_corresponding_textline(
             else:
                 pass
 
-    #####for i_drop in range(len(polygons_of_drop_capitals)):
-    #####for j_cont in range(len(contours_only_text_parent)):
-    #####img_con=np.zeros((text_regions_p.shape[0],text_regions_p.shape[1],3))
-    #####img_con=cv2.fillPoly(img_con,pts=[polygons_of_drop_capitals[i_drop] ],color=(255,255,255))
-    #####img_con=cv2.fillPoly(img_con,pts=[contours_only_text_parent[j_cont]],color=(255,255,255))
-
-    #####img_con=img_con.astype(np.uint8)
-    ######imgray = cv2.cvtColor(img_con, cv2.COLOR_BGR2GRAY)
-    ######ret, thresh = cv2.threshold(imgray, 0, 255, 0)
-
-    ######contours_new,hierarchy=cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
-
-    #####contours_new,hir_new=return_contours_of_image(img_con)
-    #####contours_new_parent=return_parent_contours( contours_new,hir_new)
-    ######plt.imshow(img_con)
-    ######plt.show()
-    #####try:
-    #####if len(contours_new_parent)==1:
-    ######print(all_found_textline_polygons[j_cont][0])
-    #####cx_t,cy_t ,_, _, _ ,_,_= find_new_features_of_contours(all_found_textline_polygons[j_cont])
-    ######print(all_box_coord[j_cont])
-    ######print(cx_t)
-    ######print(cy_t)
-    ######print(cx_d[i_drop])
-    ######print(cy_d[i_drop])
-    #####y_lines=all_box_coord[j_cont][0]+np.array(cy_t)
-
-    ######print(y_lines)
-
-    #####arg_min=np.argmin(np.abs(y_lines-y_min_d[i_drop])  )
-    ######print(arg_min)
-
-    #####cnt_nearest=np.copy(all_found_textline_polygons[j_cont][arg_min])
-    #####cnt_nearest[:,0]=all_found_textline_polygons[j_cont][arg_min][:,0]+all_box_coord[j_cont][2]
-    #####cnt_nearest[:,1]=all_found_textline_polygons[j_cont][arg_min][:,1]+all_box_coord[j_cont][0]
-
-    #####img_textlines=np.zeros((text_regions_p.shape[0],text_regions_p.shape[1],3))
-    #####img_textlines=cv2.fillPoly(img_textlines,pts=[cnt_nearest],color=(255,255,255))
-    #####img_textlines=cv2.fillPoly(img_textlines,pts=[polygons_of_drop_capitals[i_drop] ],color=(255,255,255))
-
-    #####img_textlines=img_textlines.astype(np.uint8)
-    #####imgray = cv2.cvtColor(img_textlines, cv2.COLOR_BGR2GRAY)
-    #####ret, thresh = cv2.threshold(imgray, 0, 255, 0)
-
-    #####contours_combined,hierarchy=cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
-
-    #####areas_cnt_text=np.array([cv2.contourArea(contours_combined[j]) for j in range(len(contours_combined))])
-
-    #####contours_biggest=contours_combined[np.argmax(areas_cnt_text)]
-
-    ######print(np.shape(contours_biggest))
-    ######print(contours_biggest[:])
-    #####contours_biggest[:,0,0]=contours_biggest[:,0,0]-all_box_coord[j_cont][2]
-    #####contours_biggest[:,0,1]=contours_biggest[:,0,1]-all_box_coord[j_cont][0]
-
-    #####all_found_textline_polygons[j_cont][arg_min]=contours_biggest
-    ######print(contours_biggest)
-    ######plt.imshow(img_textlines[:,:,0])
-    ######plt.show()
-    #####else:
-    #####pass
-    #####except:
-    #####pass
+    # for i_drop in range(len(polygons_of_drop_capitals)):
+    # for j_cont in range(len(contours_only_text_parent)):
+    # img_con=np.zeros((text_regions_p.shape[0],text_regions_p.shape[1],3))
+    # img_con=cv2.fillPoly(img_con,pts=[polygons_of_drop_capitals[i_drop] ],color=(255,255,255))
+    # img_con=cv2.fillPoly(img_con,pts=[contours_only_text_parent[j_cont]],color=(255,255,255))
+
+    # img_con=img_con.astype(np.uint8)
+    # imgray = cv2.cvtColor(img_con, cv2.COLOR_BGR2GRAY)
+    # ret, thresh = cv2.threshold(imgray, 0, 255, 0)
+
+    # contours_new,hierarchy=cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
+
+    # contours_new,hir_new=return_contours_of_image(img_con)
+    # contours_new_parent=return_parent_contours( contours_new,hir_new)
+    # plt.imshow(img_con)
+    # plt.show()
+    # try:
+    # if len(contours_new_parent)==1:
+    # print(all_found_textline_polygons[j_cont][0])
+    # cx_t,cy_t ,_, _, _ ,_,_= find_new_features_of_contours(all_found_textline_polygons[j_cont])
+    # print(all_box_coord[j_cont])
+    # print(cx_t)
+    # print(cy_t)
+    # print(cx_d[i_drop])
+    # print(cy_d[i_drop])
+    # y_lines=all_box_coord[j_cont][0]+np.array(cy_t)
+
+    # print(y_lines)
+
+    # arg_min=np.argmin(np.abs(y_lines-y_min_d[i_drop])  )
+    # print(arg_min)
+
+    # cnt_nearest=np.copy(all_found_textline_polygons[j_cont][arg_min])
+    # cnt_nearest[:,0]=all_found_textline_polygons[j_cont][arg_min][:,0]+all_box_coord[j_cont][2]
+    # cnt_nearest[:,1]=all_found_textline_polygons[j_cont][arg_min][:,1]+all_box_coord[j_cont][0]
+
+    # img_textlines=np.zeros((text_regions_p.shape[0],text_regions_p.shape[1],3))
+    # img_textlines=cv2.fillPoly(img_textlines,pts=[cnt_nearest],color=(255,255,255))
+    # img_textlines=cv2.fillPoly(img_textlines,pts=[polygons_of_drop_capitals[i_drop] ],color=(255,255,255))
+
+    # img_textlines=img_textlines.astype(np.uint8)
+    # imgray = cv2.cvtColor(img_textlines, cv2.COLOR_BGR2GRAY)
+    # ret, thresh = cv2.threshold(imgray, 0, 255, 0)
+
+    # contours_combined,hierarchy=cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
+
+    # areas_cnt_text=np.array([cv2.contourArea(contours_combined[j]) for j in range(len(contours_combined))])
+
+    # contours_biggest=contours_combined[np.argmax(areas_cnt_text)]
+
+    # print(np.shape(contours_biggest))
+    # print(contours_biggest[:])
+    # contours_biggest[:,0,0]=contours_biggest[:,0,0]-all_box_coord[j_cont][2]
+    # contours_biggest[:,0,1]=contours_biggest[:,0,1]-all_box_coord[j_cont][0]
+
+    # all_found_textline_polygons[j_cont][arg_min]=contours_biggest
+    # print(contours_biggest)
+    # plt.imshow(img_textlines[:,:,0])
+    # plt.show()
+    # else:
+    # pass
+    # except:
+    # pass
     return all_found_textline_polygons
 
+
 def filter_small_drop_capitals_from_no_patch_layout(layout_no_patch, layout1):
 
     drop_only = (layout_no_patch[:, :, 0] == 4) * 1
@@ -489,7 +491,7 @@ def filter_small_drop_capitals_from_no_patch_layout(layout_no_patch, layout1):
 
         if iou_of_box_and_contoure > 60 and weigh_to_height_ratio < 1.2 and height_to_weight_ratio < 2:
             map_of_drop_contour_bb = np.zeros((layout1.shape[0], layout1.shape[1]))
-            map_of_drop_contour_bb[y : y + h, x : x + w] = layout1[y : y + h, x : x + w]
+            map_of_drop_contour_bb[y: y + h, x: x + w] = layout1[y: y + h, x: x + w]
 
             if (((map_of_drop_contour_bb == 1) * 1).sum() / float(((map_of_drop_contour_bb == 5) * 1).sum()) * 100) >= 15:
                 contours_drop_parent_final.append(contours_drop_parent[jj])

src/eynollah/utils/marginals.py

@@ -3,250 +3,223 @@ import cv2
 from scipy.signal import find_peaks
 from scipy.ndimage import gaussian_filter1d
 
-
 from .contour import find_new_features_of_contours, return_contours_of_interested_region
 from .resize import resize_image
 from .rotate import rotate_image
 
-def get_marginals(text_with_lines, text_regions, num_col, slope_deskew, kernel=None):
-    mask_marginals=np.zeros((text_with_lines.shape[0],text_with_lines.shape[1]))
-    mask_marginals=mask_marginals.astype(np.uint8)
 
+def get_marginals(text_with_lines, text_regions, num_col, slope_deskew, kernel=None):
+    mask_marginals = np.zeros((text_with_lines.shape[0], text_with_lines.shape[1]))
+    mask_marginals = mask_marginals.astype(np.uint8)
 
-    text_with_lines=text_with_lines.astype(np.uint8)
-    ##text_with_lines=cv2.erode(text_with_lines,self.kernel,iterations=3)
+    text_with_lines = text_with_lines.astype(np.uint8)
+    # text_with_lines=cv2.erode(text_with_lines,self.kernel,iterations=3)
 
-    text_with_lines_eroded=cv2.erode(text_with_lines,kernel,iterations=5)
+    text_with_lines_eroded = cv2.erode(text_with_lines, kernel, iterations=5)
 
-    if text_with_lines.shape[0]<=1500:
+    if text_with_lines.shape[0] <= 1500:
         pass
-    elif text_with_lines.shape[0]>1500 and text_with_lines.shape[0]<=1800:
-        text_with_lines=resize_image(text_with_lines,int(text_with_lines.shape[0]*1.5),text_with_lines.shape[1])
-        text_with_lines=cv2.erode(text_with_lines,kernel,iterations=5)
-        text_with_lines=resize_image(text_with_lines,text_with_lines_eroded.shape[0],text_with_lines_eroded.shape[1])
+    elif text_with_lines.shape[0] > 1500 and text_with_lines.shape[0] <= 1800:
+        text_with_lines = resize_image(text_with_lines, int(text_with_lines.shape[0] * 1.5), text_with_lines.shape[1])
+        text_with_lines = cv2.erode(text_with_lines, kernel, iterations=5)
+        text_with_lines = resize_image(text_with_lines, text_with_lines_eroded.shape[0], text_with_lines_eroded.shape[1])
     else:
-        text_with_lines=resize_image(text_with_lines,int(text_with_lines.shape[0]*1.8),text_with_lines.shape[1])
-        text_with_lines=cv2.erode(text_with_lines,kernel,iterations=7)
-        text_with_lines=resize_image(text_with_lines,text_with_lines_eroded.shape[0],text_with_lines_eroded.shape[1])
-
+        text_with_lines = resize_image(text_with_lines, int(text_with_lines.shape[0] * 1.8), text_with_lines.shape[1])
+        text_with_lines = cv2.erode(text_with_lines, kernel, iterations=7)
+        text_with_lines = resize_image(text_with_lines, text_with_lines_eroded.shape[0], text_with_lines_eroded.shape[1])
 
-    text_with_lines_y=text_with_lines.sum(axis=0)
-    text_with_lines_y_eroded=text_with_lines_eroded.sum(axis=0)
+    text_with_lines_y = text_with_lines.sum(axis=0)
+    text_with_lines_y_eroded = text_with_lines_eroded.sum(axis=0)
 
-    thickness_along_y_percent=text_with_lines_y_eroded.max()/(float(text_with_lines.shape[0]))*100
+    thickness_along_y_percent = text_with_lines_y_eroded.max() / (float(text_with_lines.shape[0])) * 100
 
-    #print(thickness_along_y_percent,'thickness_along_y_percent')
+    # print(thickness_along_y_percent,'thickness_along_y_percent')
 
-    if thickness_along_y_percent<30:
-        min_textline_thickness=8
-    elif thickness_along_y_percent>=30 and thickness_along_y_percent<50:
-        min_textline_thickness=20
+    if thickness_along_y_percent < 30:
+        min_textline_thickness = 8
+    elif thickness_along_y_percent >= 30 and thickness_along_y_percent < 50:
+        min_textline_thickness = 20
     else:
-        min_textline_thickness=40
-
-
-
-    if thickness_along_y_percent>=14:
-
-        text_with_lines_y_rev=-1*text_with_lines_y[:]
-        #print(text_with_lines_y)
-        #print(text_with_lines_y_rev)
-
-
-
-
-        #plt.plot(text_with_lines_y)
-        #plt.show()
-
-
-        text_with_lines_y_rev=text_with_lines_y_rev-np.min(text_with_lines_y_rev)
-
-        #plt.plot(text_with_lines_y_rev)
-        #plt.show()
-        sigma_gaus=1
-        region_sum_0= gaussian_filter1d(text_with_lines_y, sigma_gaus)
+        min_textline_thickness = 40
 
-        region_sum_0_rev=gaussian_filter1d(text_with_lines_y_rev, sigma_gaus)
+    if thickness_along_y_percent >= 14:
 
-        #plt.plot(region_sum_0_rev)
-        #plt.show()
-        region_sum_0_updown=region_sum_0[len(region_sum_0)::-1]
+        text_with_lines_y_rev = -1 * text_with_lines_y[:]
+        # print(text_with_lines_y)
+        # print(text_with_lines_y_rev)
 
-        first_nonzero=(next((i for i, x in enumerate(region_sum_0) if x), None))
-        last_nonzero=(next((i for i, x in enumerate(region_sum_0_updown) if x), None))
+        # plt.plot(text_with_lines_y)
+        # plt.show()
 
+        text_with_lines_y_rev = text_with_lines_y_rev - np.min(text_with_lines_y_rev)
 
-        last_nonzero=len(region_sum_0)-last_nonzero
+        # plt.plot(text_with_lines_y_rev)
+        # plt.show()
+        sigma_gaus = 1
+        region_sum_0 = gaussian_filter1d(text_with_lines_y, sigma_gaus)
 
-        ##img_sum_0_smooth_rev=-region_sum_0
+        region_sum_0_rev = gaussian_filter1d(text_with_lines_y_rev, sigma_gaus)
 
+        # plt.plot(region_sum_0_rev)
+        # plt.show()
+        region_sum_0_updown = region_sum_0[len(region_sum_0)::-1]
 
-        mid_point=(last_nonzero+first_nonzero)/2.
+        first_nonzero = (next((i for i, x in enumerate(region_sum_0) if x), None))
+        last_nonzero = (next((i for i, x in enumerate(region_sum_0_updown) if x), None))
 
+        last_nonzero = len(region_sum_0) - last_nonzero
 
-        one_third_right=(last_nonzero-mid_point)/3.0
-        one_third_left=(mid_point-first_nonzero)/3.0
-
-        #img_sum_0_smooth_rev=img_sum_0_smooth_rev-np.min(img_sum_0_smooth_rev)
+        # img_sum_0_smooth_rev=-region_sum_0
 
+        mid_point = (last_nonzero + first_nonzero) / 2.
 
+        one_third_right = (last_nonzero - mid_point) / 3.0
+        one_third_left = (mid_point - first_nonzero) / 3.0
 
+        # img_sum_0_smooth_rev=img_sum_0_smooth_rev-np.min(img_sum_0_smooth_rev)
 
         peaks, _ = find_peaks(text_with_lines_y_rev, height=0)
 
+        peaks = np.array(peaks)
 
-        peaks=np.array(peaks)
-
-
-        #print(region_sum_0[peaks])
-        ##plt.plot(region_sum_0)
-        ##plt.plot(peaks,region_sum_0[peaks],'*')
-        ##plt.show()
-        #print(first_nonzero,last_nonzero,peaks)
-        peaks=peaks[(peaks>first_nonzero) & ((peaks<last_nonzero))]
-
-        #print(first_nonzero,last_nonzero,peaks)
+        # print(region_sum_0[peaks])
+        # plt.plot(region_sum_0)
+        # plt.plot(peaks,region_sum_0[peaks],'*')
+        # plt.show()
+        # print(first_nonzero,last_nonzero,peaks)
+        peaks = peaks[(peaks > first_nonzero) & (peaks < last_nonzero)]
 
+        # print(first_nonzero,last_nonzero,peaks)
 
-        #print(region_sum_0[peaks]<10)
-        ####peaks=peaks[region_sum_0[peaks]<25 ]
+        # print(region_sum_0[peaks]<10)
+        # peaks=peaks[region_sum_0[peaks]<25 ]
 
-        #print(region_sum_0[peaks])
-        peaks=peaks[region_sum_0[peaks]<min_textline_thickness ]
-        #print(peaks)
-        #print(first_nonzero,last_nonzero,one_third_right,one_third_left)
-
-        if num_col==1:
-            peaks_right=peaks[peaks>mid_point]
-            peaks_left=peaks[peaks<mid_point]
-        if num_col==2:
-            peaks_right=peaks[peaks>(mid_point+one_third_right)]
-            peaks_left=peaks[peaks<(mid_point-one_third_left)]
+        # print(region_sum_0[peaks])
+        peaks = peaks[region_sum_0[peaks] < min_textline_thickness]
+        # print(peaks)
+        # print(first_nonzero,last_nonzero,one_third_right,one_third_left)
 
+        if num_col == 1:
+            peaks_right = peaks[peaks > mid_point]
+            peaks_left = peaks[peaks < mid_point]
+        if num_col == 2:
+            peaks_right = peaks[peaks > (mid_point + one_third_right)]
+            peaks_left = peaks[peaks < (mid_point - one_third_left)]
 
         try:
-            point_right=np.min(peaks_right)
+            point_right = np.min(peaks_right)
         except:
-            point_right=last_nonzero
-
+            point_right = last_nonzero
 
         try:
-            point_left=np.max(peaks_left)
+            point_left = np.max(peaks_left)
         except:
-            point_left=first_nonzero
-
+            point_left = first_nonzero
 
-
-
-        #print(point_left,point_right)
-        #print(text_regions.shape)
-        if point_right>=mask_marginals.shape[1]:
-            point_right=mask_marginals.shape[1]-1
+        # print(point_left,point_right)
+        # print(text_regions.shape)
+        if point_right >= mask_marginals.shape[1]:
+            point_right = mask_marginals.shape[1] - 1
 
         try:
-            mask_marginals[:,point_left:point_right]=1
+            mask_marginals[:, point_left:point_right] = 1
         except:
-            mask_marginals[:,:]=1
+            mask_marginals[:, :] = 1
 
-        #print(mask_marginals.shape,point_left,point_right,'nadosh')
-        mask_marginals_rotated=rotate_image(mask_marginals,-slope_deskew)
+        # print(mask_marginals.shape,point_left,point_right,'nadosh')
+        mask_marginals_rotated = rotate_image(mask_marginals, -slope_deskew)
 
-        #print(mask_marginals_rotated.shape,'nadosh')
-        mask_marginals_rotated_sum=mask_marginals_rotated.sum(axis=0)
+        # print(mask_marginals_rotated.shape,'nadosh')
+        mask_marginals_rotated_sum = mask_marginals_rotated.sum(axis=0)
 
-        mask_marginals_rotated_sum[mask_marginals_rotated_sum!=0]=1
-        index_x=np.array(range(len(mask_marginals_rotated_sum)))+1
+        mask_marginals_rotated_sum[mask_marginals_rotated_sum != 0] = 1
+        index_x = np.array(range(len(mask_marginals_rotated_sum))) + 1
 
-        index_x_interest=index_x[mask_marginals_rotated_sum==1]
+        index_x_interest = index_x[mask_marginals_rotated_sum == 1]
 
-        min_point_of_left_marginal=np.min(index_x_interest)-16
-        max_point_of_right_marginal=np.max(index_x_interest)+16
+        min_point_of_left_marginal = np.min(index_x_interest) - 16
+        max_point_of_right_marginal = np.max(index_x_interest) + 16
 
-        if min_point_of_left_marginal<0:
-            min_point_of_left_marginal=0
-        if max_point_of_right_marginal>=text_regions.shape[1]:
-            max_point_of_right_marginal=text_regions.shape[1]-1
+        if min_point_of_left_marginal < 0:
+            min_point_of_left_marginal = 0
+        if max_point_of_right_marginal >= text_regions.shape[1]:
+            max_point_of_right_marginal = text_regions.shape[1] - 1
 
+        # print(np.min(index_x_interest) ,np.max(index_x_interest),'minmaxnew')
+        # print(mask_marginals_rotated.shape,text_regions.shape,'mask_marginals_rotated')
+        # plt.imshow(mask_marginals)
+        # plt.show()
 
-        #print(np.min(index_x_interest) ,np.max(index_x_interest),'minmaxnew')
-        #print(mask_marginals_rotated.shape,text_regions.shape,'mask_marginals_rotated')
-        #plt.imshow(mask_marginals)
-        #plt.show()
+        # plt.imshow(mask_marginals_rotated)
+        # plt.show()
 
-        #plt.imshow(mask_marginals_rotated)
-        #plt.show()
+        text_regions[(mask_marginals_rotated[:, :] != 1) & (text_regions[:, :] == 1)] = 4
 
-        text_regions[(mask_marginals_rotated[:,:]!=1) & (text_regions[:,:]==1)]=4
+        # plt.imshow(text_regions)
+        # plt.show()
 
-        #plt.imshow(text_regions)
-        #plt.show()
+        pixel_img = 4
+        min_area_text = 0.00001
+        polygons_of_marginals = return_contours_of_interested_region(text_regions, pixel_img, min_area_text)
 
-        pixel_img=4
-        min_area_text=0.00001
-        polygons_of_marginals=return_contours_of_interested_region(text_regions,pixel_img,min_area_text)
+        cx_text_only, cy_text_only, x_min_text_only, x_max_text_only, y_min_text_only, y_max_text_only, y_cor_x_min_main = find_new_features_of_contours(polygons_of_marginals)
 
-        cx_text_only,cy_text_only ,x_min_text_only,x_max_text_only, y_min_text_only ,y_max_text_only,y_cor_x_min_main=find_new_features_of_contours(polygons_of_marginals)
+        text_regions[(text_regions[:, :] == 4)] = 1
 
-        text_regions[(text_regions[:,:]==4)]=1
+        marginlas_should_be_main_text = []
 
-        marginlas_should_be_main_text=[]
-
-        x_min_marginals_left=[]
-        x_min_marginals_right=[]
+        x_min_marginals_left = []
+        x_min_marginals_right = []
 
         for i in range(len(cx_text_only)):
 
-            x_width_mar=abs(x_min_text_only[i]-x_max_text_only[i])
-            y_height_mar=abs(y_min_text_only[i]-y_max_text_only[i])
-            #print(x_width_mar,y_height_mar,y_height_mar/x_width_mar,'y_height_mar')
-            if x_width_mar>16 and y_height_mar/x_width_mar<18:
+            x_width_mar = abs(x_min_text_only[i] - x_max_text_only[i])
+            y_height_mar = abs(y_min_text_only[i] - y_max_text_only[i])
+            # print(x_width_mar,y_height_mar,y_height_mar/x_width_mar,'y_height_mar')
+            if x_width_mar > 16 and y_height_mar / x_width_mar < 18:
                 marginlas_should_be_main_text.append(polygons_of_marginals[i])
-                if x_min_text_only[i]<(mid_point-one_third_left):
-                    x_min_marginals_left_new=x_min_text_only[i]
-                    if len(x_min_marginals_left)==0:
+                if x_min_text_only[i] < (mid_point - one_third_left):
+                    x_min_marginals_left_new = x_min_text_only[i]
+                    if len(x_min_marginals_left) == 0:
                         x_min_marginals_left.append(x_min_marginals_left_new)
                     else:
-                        x_min_marginals_left[0]=min(x_min_marginals_left[0],x_min_marginals_left_new)
+                        x_min_marginals_left[0] = min(x_min_marginals_left[0], x_min_marginals_left_new)
                 else:
-                    x_min_marginals_right_new=x_min_text_only[i]
-                    if len(x_min_marginals_right)==0:
+                    x_min_marginals_right_new = x_min_text_only[i]
+                    if len(x_min_marginals_right) == 0:
                         x_min_marginals_right.append(x_min_marginals_right_new)
                     else:
-                        x_min_marginals_right[0]=min(x_min_marginals_right[0],x_min_marginals_right_new)
-
-        if len(x_min_marginals_left)==0:
-            x_min_marginals_left=[0]
-        if len(x_min_marginals_right)==0:
-            x_min_marginals_right=[text_regions.shape[1]-1]
-
-
-
+                        x_min_marginals_right[0] = min(x_min_marginals_right[0], x_min_marginals_right_new)
 
-        #print(x_min_marginals_left[0],x_min_marginals_right[0],'margo')
+        if len(x_min_marginals_left) == 0:
+            x_min_marginals_left = [0]
+        if len(x_min_marginals_right) == 0:
+            x_min_marginals_right = [text_regions.shape[1] - 1]
 
-        #print(marginlas_should_be_main_text,'marginlas_should_be_main_text')
-        text_regions=cv2.fillPoly(text_regions, pts =marginlas_should_be_main_text, color=(4,4))
+        # print(x_min_marginals_left[0],x_min_marginals_right[0],'margo')
 
-        #print(np.unique(text_regions))
+        # print(marginlas_should_be_main_text,'marginlas_should_be_main_text')
+        text_regions = cv2.fillPoly(text_regions, pts=marginlas_should_be_main_text, color=(4, 4))
 
-        #text_regions[:,:int(x_min_marginals_left[0])][text_regions[:,:int(x_min_marginals_left[0])]==1]=0
-        #text_regions[:,int(x_min_marginals_right[0]):][text_regions[:,int(x_min_marginals_right[0]):]==1]=0
+        # print(np.unique(text_regions))
 
-        text_regions[:,:int(min_point_of_left_marginal)][text_regions[:,:int(min_point_of_left_marginal)]==1]=0
-        text_regions[:,int(max_point_of_right_marginal):][text_regions[:,int(max_point_of_right_marginal):]==1]=0
+        # text_regions[:,:int(x_min_marginals_left[0])][text_regions[:,:int(x_min_marginals_left[0])]==1]=0
+        # text_regions[:,int(x_min_marginals_right[0]):][text_regions[:,int(x_min_marginals_right[0]):]==1]=0
 
-        ###text_regions[:,0:point_left][text_regions[:,0:point_left]==1]=4
+        text_regions[:, :int(min_point_of_left_marginal)][text_regions[:, :int(min_point_of_left_marginal)] == 1] = 0
+        text_regions[:, int(max_point_of_right_marginal):][text_regions[:, int(max_point_of_right_marginal):] == 1] = 0
 
-        ###text_regions[:,point_right:][ text_regions[:,point_right:]==1]=4
-        #plt.plot(region_sum_0)
-        #plt.plot(peaks,region_sum_0[peaks],'*')
-        #plt.show()
+        # text_regions[:,0:point_left][text_regions[:,0:point_left]==1]=4
 
+        # text_regions[:,point_right:][ text_regions[:,point_right:]==1]=4
+        # plt.plot(region_sum_0)
+        # plt.plot(peaks,region_sum_0[peaks],'*')
+        # plt.show()
 
-        #plt.imshow(text_regions)
-        #plt.show()
+        # plt.imshow(text_regions)
+        # plt.show()
 
-        #sys.exit()
+        # sys.exit()
     else:
         pass
     return text_regions

src/eynollah/utils/pil_cv2.py

@@ -5,15 +5,18 @@ from cv2 import COLOR_GRAY2BGR, COLOR_RGB2BGR, COLOR_BGR2RGB, cvtColor, imread
 
 # from sbb_binarization
 
+
 def cv2pil(img):
     return Image.fromarray(np.array(cvtColor(img, COLOR_BGR2RGB)))
 
+
 def pil2cv(img):
     # from ocrd/workspace.py
     color_conversion = COLOR_GRAY2BGR if img.mode in ('1', 'L') else COLOR_RGB2BGR
     pil_as_np_array = np.array(img).astype('uint8') if img.mode == '1' else np.array(img)
     return cvtColor(pil_as_np_array, color_conversion)
 
+
 def check_dpi(img):
     try:
         if isinstance(img, Image.Image):

src/eynollah/utils/resize.py

@@ -1,4 +1,5 @@
 import cv2
 
+
 def resize_image(img_in, input_height, input_width):
     return cv2.resize(img_in, (input_width, input_height), interpolation=cv2.INTER_NEAREST)

src/eynollah/utils/rotate.py

@@ -3,6 +3,7 @@ import math
 import imutils
 import cv2
 
+
 def rotatedRectWithMaxArea(w, h, angle):
     if w <= 0 or h <= 0:
         return 0, 0
@@ -25,6 +26,7 @@ def rotatedRectWithMaxArea(w, h, angle):
 
     return wr, hr
 
+
 def rotate_max_area_new(image, rotated, angle):
     wr, hr = rotatedRectWithMaxArea(image.shape[1], image.shape[0], math.radians(angle))
     h, w, _ = rotated.shape
@@ -34,17 +36,20 @@ def rotate_max_area_new(image, rotated, angle):
     x2 = x1 + int(wr)
     return rotated[y1:y2, x1:x2]
 
+
 def rotation_image_new(img, thetha):
     rotated = imutils.rotate(img, thetha)
     return rotate_max_area_new(img, rotated, thetha)
 
+
 def rotate_image(img_patch, slope):
     (h, w) = img_patch.shape[:2]
     center = (w // 2, h // 2)
     M = cv2.getRotationMatrix2D(center, slope, 1.0)
     return cv2.warpAffine(img_patch, M, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)
 
-def rotate_image_different( img, slope):
+
+def rotate_image_different(img, slope):
     # img = cv2.imread('images/input.jpg')
     num_rows, num_cols = img.shape[:2]
 
@@ -52,6 +57,7 @@ def rotate_image_different( img, slope):
     img_rotation = cv2.warpAffine(img, rotation_matrix, (num_cols, num_rows))
     return img_rotation
 
+
 def rotate_max_area(image, rotated, rotated_textline, rotated_layout, rotated_table_prediction, angle):
     wr, hr = rotatedRectWithMaxArea(image.shape[1], image.shape[0], math.radians(angle))
     h, w, _ = rotated.shape
@@ -61,6 +67,7 @@ def rotate_max_area(image, rotated, rotated_textline, rotated_layout, rotated_ta
     x2 = x1 + int(wr)
     return rotated[y1:y2, x1:x2], rotated_textline[y1:y2, x1:x2], rotated_layout[y1:y2, x1:x2], rotated_table_prediction[y1:y2, x1:x2]
 
+
 def rotation_not_90_func(img, textline, text_regions_p_1, table_prediction, thetha):
     rotated = imutils.rotate(img, thetha)
     rotated_textline = imutils.rotate(textline, thetha)
@@ -68,6 +75,7 @@ def rotation_not_90_func(img, textline, text_regions_p_1, table_prediction, thet
     rotated_table_prediction = imutils.rotate(table_prediction, thetha)
     return rotate_max_area(img, rotated, rotated_textline, rotated_layout, rotated_table_prediction, thetha)
 
+
 def rotation_not_90_func_full_layout(img, textline, text_regions_p_1, text_regions_p_fully, thetha):
     rotated = imutils.rotate(img, thetha)
     rotated_textline = imutils.rotate(textline, thetha)
@@ -75,6 +83,7 @@ def rotation_not_90_func_full_layout(img, textline, text_regions_p_1, text_regio
     rotated_layout_full = imutils.rotate(text_regions_p_fully, thetha)
     return rotate_max_area_full_layout(img, rotated, rotated_textline, rotated_layout, rotated_layout_full, thetha)
 
+
 def rotate_max_area_full_layout(image, rotated, rotated_textline, rotated_layout, rotated_layout_full, angle):
     wr, hr = rotatedRectWithMaxArea(image.shape[1], image.shape[0], math.radians(angle))
     h, w, _ = rotated.shape

src/eynollah/utils/xml.py

@@ -29,6 +29,7 @@ from ocrd_models.ocrd_page import (
 
     to_xml)
 
+
 def create_page_xml(imageFilename, height, width):
     now = datetime.now()
     pcgts = PcGtsType(
@@ -46,6 +47,7 @@ def create_page_xml(imageFilename, height, width):
         ))
     return pcgts
 
+
 def xml_reading_order(page, order_of_texts, id_of_marginalia):
     region_order = ReadingOrderType()
     og = OrderedGroupType(id="ro357564684568544579089")
@@ -59,6 +61,7 @@ def xml_reading_order(page, order_of_texts, id_of_marginalia):
         og.add_RegionRefIndexed(RegionRefIndexedType(index=str(region_counter.get('region')), regionRef=id_marginal))
         region_counter.inc('region')
 
+
 def order_and_id_of_texts(found_polygons_text_region, found_polygons_text_region_h, matrix_of_orders, indexes_sorted, index_of_types, kind_of_texts, ref_point):
     indexes_sorted = np.array(indexes_sorted)
     index_of_types = np.array(index_of_types)

src/eynollah/writer.py

@@ -17,12 +17,13 @@ from ocrd_models.ocrd_page import (
     TableRegionType,
     SeparatorRegionType,
     to_xml
-        )
+)
 import numpy as np
 
+
 class EynollahXmlWriter():
 
-    def __init__(self, *, dir_out, image_filename, curved_line,textline_light, pcgts=None):
+    def __init__(self, *, dir_out, image_filename, curved_line, textline_light, pcgts=None):
         self.logger = getLogger('eynollah.writer')
         self.counter = EynollahIdCounter()
         self.dir_out = dir_out
@@ -50,7 +51,7 @@ class EynollahXmlWriter():
             else:
                 points_page_print += str(int((contour[0][0]) / self.scale_x))
                 points_page_print += ','
-                points_page_print += str(int((contour[0][1] ) / self.scale_y))
+                points_page_print += str(int((contour[0][1]) / self.scale_y))
             points_page_print = points_page_print + ' '
         return points_page_print[:-1]
 
@@ -63,11 +64,11 @@ class EynollahXmlWriter():
             for l in range(len(all_found_textline_polygons_marginals[marginal_idx][j])):
                 if not (self.curved_line or self.textline_light):
                     if len(all_found_textline_polygons_marginals[marginal_idx][j][l]) == 2:
-                        textline_x_coord = max(0, int((all_found_textline_polygons_marginals[marginal_idx][j][l][0] + all_box_coord_marginals[marginal_idx][2] + page_coord[2]) / self.scale_x) )
-                        textline_y_coord = max(0, int((all_found_textline_polygons_marginals[marginal_idx][j][l][1] + all_box_coord_marginals[marginal_idx][0] + page_coord[0]) / self.scale_y) )
+                        textline_x_coord = max(0, int((all_found_textline_polygons_marginals[marginal_idx][j][l][0] + all_box_coord_marginals[marginal_idx][2] + page_coord[2]) / self.scale_x))
+                        textline_y_coord = max(0, int((all_found_textline_polygons_marginals[marginal_idx][j][l][1] + all_box_coord_marginals[marginal_idx][0] + page_coord[0]) / self.scale_y))
                     else:
-                        textline_x_coord = max(0, int((all_found_textline_polygons_marginals[marginal_idx][j][l][0][0] + all_box_coord_marginals[marginal_idx][2] + page_coord[2]) / self.scale_x) )
-                        textline_y_coord = max(0, int((all_found_textline_polygons_marginals[marginal_idx][j][l][0][1] + all_box_coord_marginals[marginal_idx][0] + page_coord[0]) / self.scale_y) )
+                        textline_x_coord = max(0, int((all_found_textline_polygons_marginals[marginal_idx][j][l][0][0] + all_box_coord_marginals[marginal_idx][2] + page_coord[2]) / self.scale_x))
+                        textline_y_coord = max(0, int((all_found_textline_polygons_marginals[marginal_idx][j][l][0][1] + all_box_coord_marginals[marginal_idx][0] + page_coord[0]) / self.scale_y))
                     points_co += str(textline_x_coord)
                     points_co += ','
                     points_co += str(textline_y_coord)
@@ -121,16 +122,16 @@ class EynollahXmlWriter():
                     else:
                         points_co += str(int((contour_textline[0][0] + page_coord[2]) / self.scale_x))
                         points_co += ','
-                        points_co += str(int((contour_textline[0][1] + page_coord[0])/self.scale_y))
+                        points_co += str(int((contour_textline[0][1] + page_coord[0]) / self.scale_y))
                 elif (self.curved_line or self.textline_light) and np.abs(slopes[region_idx]) > 45:
-                    if len(contour_textline)==2:
-                        points_co += str(int((contour_textline[0] + region_bboxes[2] + page_coord[2])/self.scale_x))
+                    if len(contour_textline) == 2:
+                        points_co += str(int((contour_textline[0] + region_bboxes[2] + page_coord[2]) / self.scale_x))
                         points_co += ','
-                        points_co += str(int((contour_textline[1] + region_bboxes[0] + page_coord[0])/self.scale_y))
+                        points_co += str(int((contour_textline[1] + region_bboxes[0] + page_coord[0]) / self.scale_y))
                     else:
-                        points_co += str(int((contour_textline[0][0] + region_bboxes[2]+page_coord[2])/self.scale_x))
+                        points_co += str(int((contour_textline[0][0] + region_bboxes[2] + page_coord[2]) / self.scale_x))
                         points_co += ','
-                        points_co += str(int((contour_textline[0][1] + region_bboxes[0]+page_coord[0])/self.scale_y))
+                        points_co += str(int((contour_textline[0][1] + region_bboxes[0] + page_coord[0]) / self.scale_y))
                 points_co += ' '
             coords.set_points(points_co[:-1])
 
@@ -140,7 +141,11 @@ class EynollahXmlWriter():
         with open(out_fname, 'w') as f:
             f.write(to_xml(pcgts))
 
-    def build_pagexml_no_full_layout(self, found_polygons_text_region, page_coord, order_of_texts, id_of_texts, all_found_textline_polygons, all_box_coord, found_polygons_text_region_img, found_polygons_marginals, all_found_textline_polygons_marginals, all_box_coord_marginals, slopes, slopes_marginals, cont_page, polygons_lines_to_be_written_in_xml, found_polygons_tables):
+    def build_pagexml_no_full_layout(self, found_polygons_text_region, page_coord, order_of_texts, id_of_texts,
+                                     all_found_textline_polygons, all_box_coord, found_polygons_text_region_img,
+                                     found_polygons_marginals, all_found_textline_polygons_marginals,
+                                     all_box_coord_marginals, slopes, slopes_marginals, cont_page,
+                                     polygons_lines_to_be_written_in_xml, found_polygons_tables):
         self.logger.debug('enter build_pagexml_no_full_layout')
 
         # create the file structure
@@ -156,8 +161,7 @@ class EynollahXmlWriter():
 
         for mm in range(len(found_polygons_text_region)):
             textregion = TextRegionType(id=counter.next_region_id, type_='paragraph',
-                    Coords=CoordsType(points=self.calculate_polygon_coords(found_polygons_text_region[mm], page_coord)),
-                    )
+                                        Coords=CoordsType(points=self.calculate_polygon_coords(found_polygons_text_region[mm], page_coord)),)
             page.add_TextRegion(textregion)
             self.serialize_lines_in_region(textregion, all_found_textline_polygons, mm, page_coord, all_box_coord, slopes, counter)
 
@@ -173,15 +177,15 @@ class EynollahXmlWriter():
             points_co = ''
             for lmm in range(len(found_polygons_text_region_img[mm])):
                 try:
-                    points_co += str(int((found_polygons_text_region_img[mm][lmm,0,0] + page_coord[2]) / self.scale_x))
+                    points_co += str(int((found_polygons_text_region_img[mm][lmm, 0, 0] + page_coord[2]) / self.scale_x))
                     points_co += ','
-                    points_co += str(int((found_polygons_text_region_img[mm][lmm,0,1] + page_coord[0]) / self.scale_y))
+                    points_co += str(int((found_polygons_text_region_img[mm][lmm, 0, 1] + page_coord[0]) / self.scale_y))
                     points_co += ' '
                 except:
 
-                    points_co +=  str(int((found_polygons_text_region_img[mm][lmm][0] + page_coord[2])/ self.scale_x  ))
+                    points_co += str(int((found_polygons_text_region_img[mm][lmm][0] + page_coord[2]) / self.scale_x))
                     points_co += ','
-                    points_co += str(int((found_polygons_text_region_img[mm][lmm][1] + page_coord[0])/ self.scale_y  ))
+                    points_co += str(int((found_polygons_text_region_img[mm][lmm][1] + page_coord[0]) / self.scale_y))
                     points_co += ' '
 
             img_region.get_Coords().set_points(points_co[:-1])
@@ -191,9 +195,9 @@ class EynollahXmlWriter():
             page.add_SeparatorRegion(sep_hor)
             points_co = ''
             for lmm in range(len(polygons_lines_to_be_written_in_xml[mm])):
-                points_co += str(int((polygons_lines_to_be_written_in_xml[mm][lmm,0,0] ) / self.scale_x))
+                points_co += str(int((polygons_lines_to_be_written_in_xml[mm][lmm, 0, 0]) / self.scale_x))
                 points_co += ','
-                points_co += str(int((polygons_lines_to_be_written_in_xml[mm][lmm,0,1] ) / self.scale_y))
+                points_co += str(int((polygons_lines_to_be_written_in_xml[mm][lmm, 0, 1]) / self.scale_y))
                 points_co += ' '
             sep_hor.get_Coords().set_points(points_co[:-1])
         for mm in range(len(found_polygons_tables)):
@@ -201,15 +205,21 @@ class EynollahXmlWriter():
             page.add_TableRegion(tab_region)
             points_co = ''
             for lmm in range(len(found_polygons_tables[mm])):
-                points_co += str(int((found_polygons_tables[mm][lmm,0,0] + page_coord[2]) / self.scale_x))
+                points_co += str(int((found_polygons_tables[mm][lmm, 0, 0] + page_coord[2]) / self.scale_x))
                 points_co += ','
-                points_co += str(int((found_polygons_tables[mm][lmm,0,1] + page_coord[0]) / self.scale_y))
+                points_co += str(int((found_polygons_tables[mm][lmm, 0, 1] + page_coord[0]) / self.scale_y))
                 points_co += ' '
             tab_region.get_Coords().set_points(points_co[:-1])
 
         return pcgts
 
-    def build_pagexml_full_layout(self, found_polygons_text_region, found_polygons_text_region_h, page_coord, order_of_texts, id_of_texts, all_found_textline_polygons, all_found_textline_polygons_h, all_box_coord, all_box_coord_h, found_polygons_text_region_img, found_polygons_tables, found_polygons_drop_capitals, found_polygons_marginals, all_found_textline_polygons_marginals, all_box_coord_marginals, slopes, slopes_h, slopes_marginals, cont_page, polygons_lines_to_be_written_in_xml):
+    def build_pagexml_full_layout(self, found_polygons_text_region, found_polygons_text_region_h, page_coord,
+                                  order_of_texts, id_of_texts, all_found_textline_polygons,
+                                  all_found_textline_polygons_h, all_box_coord, all_box_coord_h,
+                                  found_polygons_text_region_img, found_polygons_tables, found_polygons_drop_capitals,
+                                  found_polygons_marginals, all_found_textline_polygons_marginals,
+                                  all_box_coord_marginals, slopes, slopes_h, slopes_marginals, cont_page,
+                                  polygons_lines_to_be_written_in_xml):
         self.logger.debug('enter build_pagexml_full_layout')
 
         # create the file structure
@@ -246,13 +256,16 @@ class EynollahXmlWriter():
                                                Coords=CoordsType(points=self.calculate_polygon_coords(found_polygons_drop_capitals[mm], page_coord))))
 
         for mm in range(len(found_polygons_text_region_img)):
-            page.add_ImageRegion(ImageRegionType(id=counter.next_region_id, Coords=CoordsType(points=self.calculate_polygon_coords(found_polygons_text_region_img[mm], page_coord))))
+            page.add_ImageRegion(ImageRegionType(id=counter.next_region_id, Coords=CoordsType(
+                points=self.calculate_polygon_coords(found_polygons_text_region_img[mm], page_coord))))
 
         for mm in range(len(polygons_lines_to_be_written_in_xml)):
-            page.add_SeparatorRegion(ImageRegionType(id=counter.next_region_id, Coords=CoordsType(points=self.calculate_polygon_coords(polygons_lines_to_be_written_in_xml[mm], [0 , 0, 0, 0]))))
+            page.add_SeparatorRegion(ImageRegionType(id=counter.next_region_id, Coords=CoordsType(
+                points=self.calculate_polygon_coords(polygons_lines_to_be_written_in_xml[mm], [0, 0, 0, 0]))))
 
         for mm in range(len(found_polygons_tables)):
-            page.add_TableRegion(TableRegionType(id=counter.next_region_id, Coords=CoordsType(points=self.calculate_polygon_coords(found_polygons_tables[mm], page_coord))))
+            page.add_TableRegion(TableRegionType(id=counter.next_region_id, Coords=CoordsType(
+                points=self.calculate_polygon_coords(found_polygons_tables[mm], page_coord))))
 
         return pcgts
 
@@ -268,6 +281,5 @@ class EynollahXmlWriter():
                 coords += str(int((value_bbox[0][0] + page_coord[2]) / self.scale_x))
                 coords += ','
                 coords += str(int((value_bbox[0][1] + page_coord[0]) / self.scale_y))
-            coords=coords + ' '
+            coords = coords + ' '
         return coords[:-1]
-

tests/base.py

@@ -10,12 +10,14 @@ from unittest import TestCase as VanillaTestCase, skip, main as unittests_main
 import pytest
 from ocrd_utils import disableLogging, initLogging
 
+
 def main(fn=None):
     if fn:
         sys.exit(pytest.main([fn]))
     else:
         unittests_main()
 
+
 class TestCase(VanillaTestCase):
 
     @classmethod
@@ -26,6 +28,7 @@ class TestCase(VanillaTestCase):
         disableLogging()
         initLogging()
 
+
 class CapturingTestCase(TestCase):
     """
     A TestCase that needs to capture stderr/stdout and invoke click CLI.

tests/test_counter.py

@@ -1,6 +1,7 @@
 from tests.base import main
 from src.eynollah.utils.counter import EynollahIdCounter
 
+
 def test_counter_string():
     c = EynollahIdCounter()
     assert c.next_region_id == 'region_0001'
@@ -11,6 +12,7 @@ def test_counter_string():
     assert c.region_id(999) == 'region_0999'
     assert c.line_id(999, 888) == 'region_0999_line_0888'
 
+
 def test_counter_init():
     c = EynollahIdCounter(region_idx=2)
     assert c.get('region') == 2
@@ -19,6 +21,7 @@ def test_counter_init():
     c.reset()
     assert c.get('region') == 2
 
+
 def test_counter_methods():
     c = EynollahIdCounter()
     assert c.get('region') == 0
@@ -29,5 +32,6 @@ def test_counter_methods():
     c.inc('region', -9)
     assert c.get('region') == 1
 
+
 if __name__ == '__main__':
     main(__file__)

tests/test_dpi.py

@@ -3,9 +3,11 @@ from pathlib import Path
 from src.eynollah.utils.pil_cv2 import check_dpi
 from tests.base import main
 
+
 def test_dpi():
     fpath = str(Path(__file__).parent.joinpath('resources', 'kant_aufklaerung_1784_0020.tif'))
     assert 230 == check_dpi(cv2.imread(fpath))
 
+
 if __name__ == '__main__':
     main(__file__)

tests/test_run.py

@@ -8,6 +8,7 @@ testdir = Path(__file__).parent.resolve()
 
 EYNOLLAH_MODELS = environ.get('EYNOLLAH_MODELS', str(testdir.joinpath('..', 'models_eynollah').resolve()))
 
+
 class TestEynollahRun(TestCase):
 
     def test_full_run(self):
@@ -20,5 +21,6 @@ class TestEynollahRun(TestCase):
             print(code, out, err)
             assert not code
 
+
 if __name__ == '__main__':
     main(__file__)

tests/test_xml.py

@@ -4,11 +4,13 @@ from ocrd_models.ocrd_page import to_xml
 
 PAGE_2019 = 'http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15'
 
+
 def test_create_xml():
     pcgts = create_page_xml('/path/to/img.tif', 100, 100)
     xmlstr = to_xml(pcgts)
     assert 'xmlns:pc="%s"' % PAGE_2019 in xmlstr
     assert 'Metadata' in xmlstr
 
+
 if __name__ == '__main__':
     main([__file__])