| 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 |
|
|
|
|
