| import cv2, os, time
|
| import numpy as np
|
|
|
|
|
| def calculate_derivatives(gx, gy):
|
| mag = np.sqrt(gx*gx + gy*gy)
|
| if mag==0:
|
| return False, -1, -1
|
| else:
|
| return True, gx / mag, gy / mag
|
|
|
| def sw_calculator(mask, canny_img, gradient_x, gradient_y, show_process=False):
|
| height, width = canny_img.shape[0], canny_img.shape[1]
|
|
|
| if show_process:
|
| drawborder = np.zeros((canny_img.shape[0], canny_img.shape[1], 3), dtype=np.uint8)
|
|
|
| pnts = np.where(np.logical_and(canny_img != 0, mask!=0))
|
| total_pnt_num = pnts[0].shape[0]
|
| sample_pnt_num = 150
|
| sample_step = total_pnt_num / sample_pnt_num if total_pnt_num > sample_pnt_num else 1
|
|
|
| cur_pnt_ind = 0
|
| ray_list = []
|
|
|
| while cur_pnt_ind < total_pnt_num:
|
| start_x, start_y = pnts[1][cur_pnt_ind], pnts[0][cur_pnt_ind]
|
| ray_arr = [start_x, start_y, -1, -1, -1]
|
| valid, dx, dy = calculate_derivatives(gradient_x[start_y][start_x], gradient_y[start_y][start_x])
|
|
|
| if valid:
|
| inc = 0.2
|
| cur_x, cur_y = start_x + inc * dx, start_y + inc * dy
|
| while (True):
|
| tmp_curx, tmp_cury = int(cur_x), int(cur_y)
|
| if tmp_curx < 0 or tmp_curx >= width or tmp_cury <= 0 or tmp_cury >= height:
|
| break
|
| if canny_img[tmp_cury][tmp_curx] == 0:
|
| valid, dx_t, dy_t = calculate_derivatives(gradient_x[tmp_cury][tmp_curx], gradient_y[tmp_cury][tmp_curx])
|
| if not valid:
|
| break
|
| if np.arccos(-dx * dx_t + -dy * dy_t) < np.pi / 2.0:
|
| ray_arr[2] = tmp_curx
|
| ray_arr[3] = tmp_cury
|
| ray_arr[4] = np.sqrt((start_x - tmp_curx)**2 + (start_y - tmp_cury)**2)
|
| break
|
| cur_x += dx
|
| cur_y += dy
|
| if ray_arr[2] != -1:
|
| ray_list.append(ray_arr)
|
| if show_process:
|
| drawborder = cv2.arrowedLine(drawborder, (ray_arr[0], ray_arr[1]), (ray_arr[2], ray_arr[3]),
|
| (0, 255, 0), 1)
|
|
|
| cur_pnt_ind += sample_step
|
| cur_pnt_ind = int(round(cur_pnt_ind))
|
| if show_process and len(ray_list) != 0:
|
| ray_list.sort(key=lambda x: x[4])
|
| cv2.imshow("border", drawborder)
|
| cv2.imshow("cannyimg", canny_img)
|
| cv2.waitKey(0)
|
| return ray_list
|
|
|
| def strokewidth_check(text_mask, labels, num_labels, stats, debug_type=0):
|
| rays_width = []
|
| height, width = text_mask.shape[0], text_mask.shape[1]
|
|
|
| blur_img = cv2.dilate(text_mask ,(3,3),cv2.BORDER_DEFAULT)
|
|
|
|
|
|
|
| _, canny_img = cv2.threshold(text_mask, 1, 255, cv2.THRESH_OTSU+cv2.THRESH_BINARY)
|
| blur2 = blur_img.astype(float) / 255
|
| gradient_x = cv2.Scharr(blur2, ddepth=-1, dx=1, dy=0)
|
| gradient_x = cv2.GaussianBlur(gradient_x ,(3, 3),cv2.BORDER_DEFAULT)
|
| gradient_y = cv2.Scharr(blur2, ddepth=-1, dx=0, dy=1)
|
| gradient_y = cv2.GaussianBlur(gradient_y ,(3, 3),cv2.BORDER_DEFAULT)
|
|
|
| img_area = text_mask.shape[0] * text_mask.shape[1]
|
| show_process = True if debug_type > 0 else False
|
| for lab in range(num_labels):
|
| stat = stats[lab]
|
| if lab != 0 and stat[4] > img_area * 0.002:
|
| x1, y1, x2, y2 = stat[0] - 2, stat[1] - 2, stat[0] + stat[2] + 2, stat[1] + stat[3] + 2
|
| x1, x2 = max(x1, 0), min(x2, width)
|
| y1, y2 = max(y1, 0), min(y2, height)
|
| labcord = np.where(labels==lab)
|
| labcord2 = (labcord[0] - y1, labcord[1] - x1)
|
| text_roi = np.zeros((y2-y1, x2-x1), dtype=np.uint8)
|
| text_roi[labcord2] = 255
|
| text_roi = cv2.GaussianBlur(text_roi ,(3,3), cv2.BORDER_DEFAULT)
|
| ray_list = sw_calculator(text_roi,
|
| canny_img[y1: y2, x1: x2],
|
| gradient_x[y1: y2, x1: x2],
|
| gradient_y[y1: y2, x1: x2],
|
| show_process=show_process)
|
| if len(ray_list) != 0:
|
| ray_list.sort(key=lambda x: x[4])
|
| rays_width.append([int(lab), ray_list[int(len(ray_list)/2)][4]])
|
|
|
| if len(rays_width) != 0:
|
| rays_width = np.array(rays_width)
|
| mean_width = np.mean(rays_width[:, 1])
|
| ma = np.int0(rays_width[:, 0])
|
| mean_area = np.mean(stats[ma][:, 4])
|
|
|
| false_labels = np.where(rays_width[:, 1] > 2*mean_width)[0]
|
| false_labels = rays_width[false_labels, 0].astype(np.int32)
|
| for fl in false_labels:
|
| if stats[fl][4] > 2 * mean_area:
|
| text_mask[np.where(labels==fl)] = 0
|
| return text_mask
|
|
|
|
|
