|
|
import cv2, os, re, random |
|
|
import numpy as np |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class TextSpan(object): |
|
|
def __init__(self, top_bnd=None, bottom_bnd=None, left_bnd=None, right_bnd=None): |
|
|
self.top = top_bnd |
|
|
self.bottom = bottom_bnd |
|
|
self.height = self.bottom - self.top if bottom_bnd is not None else None |
|
|
|
|
|
self.left = left_bnd |
|
|
self.right = right_bnd |
|
|
self.width = self.right - self.left if right_bnd is not None else None |
|
|
|
|
|
def set_top(self, top_bnd): |
|
|
self.top = top_bnd |
|
|
return True |
|
|
|
|
|
def set_bottom(self, bottom_bnd): |
|
|
if self.top is None or bottom_bnd <= self.top: |
|
|
return False |
|
|
self.bottom = bottom_bnd |
|
|
self.height = self.bottom - self.top |
|
|
return True |
|
|
|
|
|
def set_left(self, left_bnd): |
|
|
self.left = left_bnd |
|
|
return True |
|
|
|
|
|
def set_right(self, right_bnd): |
|
|
if self.left is None or right_bnd <= self.left: |
|
|
return False |
|
|
self.right = right_bnd |
|
|
self.width = right_bnd - self.left |
|
|
return True |
|
|
|
|
|
def __getitem__(self, index): |
|
|
if isinstance(index, int) and index >=0 and index < 4: |
|
|
return [self.left, self.top, self.right, self.bottom][index] |
|
|
else: |
|
|
raise AttributeError(f'Invalid key: {index}') |
|
|
|
|
|
def split_step0(span, thresh, sumby_yaxis, thresh2=None) -> list[TextSpan]: |
|
|
candidate_pnts = (np.where(sumby_yaxis[span.top: span.bottom] > thresh)[0] + span.top).tolist() |
|
|
span_list = [] |
|
|
if len(candidate_pnts) == 0: |
|
|
return None |
|
|
stride_tol = 1 |
|
|
span0, span1 = TextSpan(candidate_pnts[0]), TextSpan() |
|
|
for pnt_ind in range(len(candidate_pnts)-1): |
|
|
if candidate_pnts[pnt_ind+1] - candidate_pnts[pnt_ind] > stride_tol: |
|
|
if not span0.set_bottom(candidate_pnts[pnt_ind]): |
|
|
continue |
|
|
span_list = split_step1(span0, span_list, thresh=thresh2, sumby_yaxis=sumby_yaxis) |
|
|
span1.set_top(candidate_pnts[pnt_ind+1]) |
|
|
span0 = span1 |
|
|
span1 = TextSpan() |
|
|
|
|
|
if len(candidate_pnts)-1 == 0: |
|
|
if candidate_pnts[0] == candidate_pnts[-1]: |
|
|
span_list = None |
|
|
else: |
|
|
span0 = TextSpan(candidate_pnts[0], candidate_pnts[-1]) |
|
|
span_list = split_step1(span0, span_list, thresh=thresh2, sumby_yaxis=sumby_yaxis) |
|
|
elif span0.top != candidate_pnts[-1]: |
|
|
span0.set_bottom(candidate_pnts[-1]) |
|
|
span_list = split_step1(span0, span_list, thresh=thresh2, sumby_yaxis=sumby_yaxis) |
|
|
|
|
|
return span_list |
|
|
|
|
|
|
|
|
|
|
|
def split_step1(span, span_list, thresh=None, sumby_yaxis=None): |
|
|
if thresh is None: |
|
|
span_list.append(span) |
|
|
return span_list |
|
|
else: |
|
|
subspan_list = split_step0(span, thresh, sumby_yaxis) |
|
|
|
|
|
if subspan_list is not None: |
|
|
|
|
|
_, maxspan = find_span(subspan_list, max) |
|
|
_, minspan = find_span(subspan_list, min) |
|
|
|
|
|
sum_height = sum(c.height for c in subspan_list) |
|
|
|
|
|
if maxspan.height / minspan.height > 2.5 or sum_height / span.height < 0.3 or len(subspan_list) == 1: |
|
|
subspan_list = None |
|
|
if subspan_list is not None and len(subspan_list) > 1: |
|
|
span_list += subspan_list |
|
|
else: |
|
|
span_list.append(span) |
|
|
return span_list |
|
|
|
|
|
|
|
|
|
|
|
def shrink_span_list(src_img, span_list, shrink_vert_space=True, shrink_hor_space=True): |
|
|
height, width = src_img.shape[0], src_img.shape[1] |
|
|
|
|
|
sum_spacing = 0 |
|
|
if shrink_vert_space: |
|
|
for ii in range(len(span_list)-1): |
|
|
line_spacing = span_list[ii+1].top - span_list[ii].bottom |
|
|
sum_spacing += line_spacing |
|
|
line_spacing = int(round(line_spacing / 2)) |
|
|
span_list[ii+1].top -= line_spacing |
|
|
span_list[ii].set_bottom(span_list[ii].bottom + line_spacing) |
|
|
|
|
|
if len(span_list) >= 2: |
|
|
mean_spacing = int(0.5 * round(sum_spacing / (len(span_list)-1))) |
|
|
span_list[0].top = max(0, span_list[0].top-mean_spacing) |
|
|
span_list[0].set_bottom(span_list[0].bottom) |
|
|
span_list[-1].set_bottom(min(src_img.shape[0], span_list[-1].bottom)) |
|
|
|
|
|
left_var, middle_var = -1, -1 |
|
|
if shrink_hor_space: |
|
|
left_pnts, middle_pnts = [], [] |
|
|
for ii in range(len(span_list)): |
|
|
s = span_list[ii] |
|
|
im = src_img[s.top: s.bottom, 0: width] |
|
|
sumby_yaxis = np.mean(im, axis=0) |
|
|
content_array = np.where(sumby_yaxis > 10)[0].tolist() |
|
|
left, right = 0, width |
|
|
if len(content_array) != 0: |
|
|
left, right = content_array[0], content_array[-1] |
|
|
span_list[ii].set_left(left) |
|
|
span_list[ii].set_right(right) |
|
|
s = span_list[ii] |
|
|
left_pnts.append(left) |
|
|
middle_pnts.append((left+right)/2) |
|
|
left_var, middle_var = np.var(np.array(left_pnts)), np.var(np.array(middle_pnts)) |
|
|
|
|
|
return span_list, (left_var, middle_var) |
|
|
|
|
|
|
|
|
|
|
|
def find_span(span_list, max_or_min=max, key="height"): |
|
|
if key=="height": |
|
|
return max_or_min(enumerate(span_list), key=(lambda x: span_list[x[0]].height), default = -1) |
|
|
else: |
|
|
return max_or_min(enumerate(span_list), key=(lambda x: span_list[x[0]].width), default = -1) |
|
|
|
|
|
|
|
|
|
|
|
def discard_spans(span_list, thresh_ratio=0.3): |
|
|
index, max_span = find_span(span_list, max) |
|
|
max_height = max_span.height |
|
|
height_thresh = max_height * thresh_ratio |
|
|
new_spanlist = [] |
|
|
for sp in span_list: |
|
|
if sp.height < height_thresh: |
|
|
continue |
|
|
new_spanlist.append(sp) |
|
|
|
|
|
return new_spanlist |
|
|
|
|
|
|
|
|
|
|
|
def plot_mapresult(sumbyvector, xlength, span_list=None, thresh=None): |
|
|
'''for experiment''' |
|
|
try: |
|
|
import matplotlib.pyplot as plt |
|
|
plt.plot(sumbyvector) |
|
|
plt.ylabel('div pnt value') |
|
|
plt.xlabel('div pnt coord') |
|
|
s = [0, 255] |
|
|
x_cords = [] |
|
|
if span_list is not None: |
|
|
for sp in span_list: |
|
|
x_cords.append(sp.top) |
|
|
x_cords.append(sp.bottom) |
|
|
if thresh is not None: |
|
|
for tr in thresh: |
|
|
plt.vlines(x = x_cords, ymin = 0, ymax = max(s), |
|
|
colors = 'purple', |
|
|
label = 'vline_multiple - full height') |
|
|
plt.hlines(y = tr * sumbyvector.mean(), xmin = 0, xmax = xlength, linestyles='--') |
|
|
plt.show() |
|
|
except: |
|
|
pass |
|
|
|
|
|
|
|
|
|
|
|
def box(width, height): |
|
|
return np.ones((height, width), dtype=np.uint8) |
|
|
|
|
|
|
|
|
def crop_img(img, crop_ratio=0.2, clip_width=True, dilate=False): |
|
|
h, w = img.shape[:2] |
|
|
moments = cv2.moments(img) |
|
|
area = moments['m00'] |
|
|
if area != 0: |
|
|
mean_x = int(round(moments['m10'] / area)) |
|
|
mean_y = int(round(moments['m01'] / area)) |
|
|
crop_r = int(round(crop_ratio * w)) |
|
|
if clip_width: |
|
|
crop_x0 = np.clip(mean_x - crop_r, 0, w) |
|
|
crop_x1 = np.clip(mean_x + crop_r, 0, w) |
|
|
if crop_x1 > crop_x0: |
|
|
img = img[:, crop_x0: crop_x1] |
|
|
else: |
|
|
crop_r = np.clip(crop_r * 2, 0, w - 1) |
|
|
img = img[:, crop_r:] |
|
|
img = np.copy(img) |
|
|
if clip_width and dilate: |
|
|
w = int(round(w/7)) |
|
|
if w > 1: |
|
|
img = cv2.dilate(img, box(w, 1), 1) |
|
|
return img, img.shape[0], img.shape[1] |
|
|
|
|
|
|
|
|
|
|
|
def split_textblock(src_img, crop_ratio=0.2, blur=False, show_process=False, discard=True, shrink=True, recheck=False, clip_width=True, dilate=True): |
|
|
|
|
|
if blur: |
|
|
src_img = cv2.GaussianBlur(src_img,(3,3),cv2.BORDER_DEFAULT) |
|
|
if crop_ratio > 0: |
|
|
img, height, width = crop_img(src_img, crop_ratio=crop_ratio, clip_width=clip_width, dilate=dilate) |
|
|
else: |
|
|
img, height, width = src_img, src_img.shape[0], src_img.shape[1] |
|
|
|
|
|
sumby_yaxis = img.mean(axis=1) |
|
|
bound0 = np.where(sumby_yaxis > sumby_yaxis.mean() * 0.1)[0].tolist() |
|
|
vars = (-1, -1) |
|
|
|
|
|
if len(bound0) < 2: |
|
|
return [TextSpan(0, height-1, 0, width - 1)], vars |
|
|
|
|
|
base_span = TextSpan(bound0[0], bound0[-1]) |
|
|
meanby_yaxis = sumby_yaxis.mean() |
|
|
|
|
|
thresh_ratio = [0.4, 0.8] |
|
|
thresh0 = meanby_yaxis * thresh_ratio[0] |
|
|
thresh2 = meanby_yaxis * thresh_ratio[1] |
|
|
|
|
|
span_list = split_step0(base_span, thresh0, sumby_yaxis, thresh2=thresh2) |
|
|
if span_list is None: |
|
|
return None, None |
|
|
if discard: |
|
|
span_list = discard_spans(span_list) |
|
|
if shrink: |
|
|
span_list, vars = shrink_span_list(src_img, span_list) |
|
|
|
|
|
'''for experiment''' |
|
|
if show_process: |
|
|
plot_mapresult(sumby_yaxis, height, span_list=span_list, thresh=thresh_ratio) |
|
|
|
|
|
if recheck and len(span_list) == 1 and crop_ratio > 0: |
|
|
return split_textblock(src_img, crop_ratio==-1, show_process=show_process, discard=discard, shrink=shrink, recheck=False) |
|
|
|
|
|
valid_span_list = [] |
|
|
for span in span_list: |
|
|
if span.top is None: |
|
|
span.set_top(0) |
|
|
if span.left is None: |
|
|
span.set_left(0) |
|
|
if span.right is None: |
|
|
span.set_right(width) |
|
|
if span.bottom is None: |
|
|
span.set_bottom(height) |
|
|
valid_span_list.append(span) |
|
|
|
|
|
return valid_span_list, vars |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def textspan2list(span_list): |
|
|
converted_list = [] |
|
|
for ii, s in enumerate(span_list): |
|
|
converted_list.append([]) |
|
|
converted_list[ii].append(s.top) |
|
|
converted_list[ii].append(s.left) |
|
|
converted_list[ii].append(s.bottom) |
|
|
converted_list[ii].append(s.right) |
|
|
return converted_list |
|
|
|
|
|
|
|
|
|
|
|
def manga_split(img, bbox=None, show_process=False, clip_width=False) -> list[TextSpan]: |
|
|
|
|
|
im = cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE) |
|
|
imh, imw = im.shape[:2] |
|
|
|
|
|
if bbox is None: |
|
|
bbox = [0, 0, im.shape[1], im.shape[0]] |
|
|
bboxes = [bbox] |
|
|
|
|
|
span_list, _ = split_textblock(im, show_process=show_process, shrink=False, recheck=True, discard=False, crop_ratio=0) |
|
|
if span_list is None: |
|
|
return [TextSpan(0, 0, im.shape[1], im.shape[0])] |
|
|
|
|
|
|
|
|
for ii, span in enumerate(span_list): |
|
|
left = span.left |
|
|
right = span.right |
|
|
if ii == 0: |
|
|
span.left = 0 |
|
|
else: |
|
|
span.left = span.top |
|
|
if ii == len(span_list) - 1: |
|
|
span.right = im.shape[0] |
|
|
else: |
|
|
span.right = span.bottom |
|
|
span.top = imw - right |
|
|
span.bottom = imw - left |
|
|
span.height = span.bottom - span.top |
|
|
span.width = span.right - span.left |
|
|
|
|
|
return span_list |
|
|
|
|
|
|
|
|
def tessocr_img2text_linemode(img, span_list=None, combine_lines=True, show_process=False, gen_data=False, lang="comic6k", jpn_vert=False): |
|
|
if jpn_vert: |
|
|
lang = "jpn_vert" |
|
|
img = cv2.rotate(img, cv2.ROTATE_90_COUNTERCLOCKWISE) |
|
|
hig = img.shape[0] |
|
|
wid = img.shape[1] |
|
|
if hig * wid < 5: |
|
|
return '', -1, -1 |
|
|
|
|
|
bw = 3 |
|
|
text = '' |
|
|
alignment, vars = 0, (-1, -1) |
|
|
if span_list is None: |
|
|
span_list, vars = split_textblock(img, show_process=show_process) |
|
|
_, maxspan = find_span(span_list, max) |
|
|
maxh = bw*2 + maxspan.height |
|
|
else: |
|
|
maxh = max([s[2]-s[0] for s in span_list]) |
|
|
maxh = bw*2 + maxh |
|
|
|
|
|
long_line = [] |
|
|
word_space = int(round(maxh / 8)) |
|
|
img = 255 - img |
|
|
for ind, s in enumerate(span_list): |
|
|
if isinstance(s, list): |
|
|
im = img[s[0]: s[2], s[1]: s[3]] |
|
|
else: |
|
|
im = img[s.top: s.bottom, s.left: s.right] |
|
|
|
|
|
hw1 = int(round((maxh - im.shape[0])/2)) |
|
|
hw2 = maxh - hw1 - im.shape[0] |
|
|
dst = cv2.copyMakeBorder(im, hw1, hw2, word_space, word_space, cv2.BORDER_CONSTANT, None, value=[255, 255, 255]) |
|
|
|
|
|
if not combine_lines: |
|
|
text += tessocr_img2text(dst, lang=lang) +'\n' |
|
|
else: |
|
|
long_line.append(dst) |
|
|
if show_process: |
|
|
cv2.imshow(str(ind), dst) |
|
|
|
|
|
if combine_lines: |
|
|
long_line = cv2.hconcat(long_line) |
|
|
if jpn_vert: |
|
|
long_line = cv2.rotate(long_line, cv2.ROTATE_90_CLOCKWISE) |
|
|
if show_process: |
|
|
cv2.namedWindow("long line:", cv2.WINDOW_NORMAL) |
|
|
cv2.imshow("long line:", long_line) |
|
|
if gen_data: |
|
|
return long_line |
|
|
res = tessocr_img2text(long_line, lang=lang) |
|
|
mean_height = -1 |
|
|
if len(span_list) != 0: |
|
|
if isinstance(span_list[0], list): |
|
|
mean_height = np.mean(np.array([s[2]-s[0] for s in span_list])) |
|
|
else: |
|
|
mean_height = np.mean(np.array([s.height for s in span_list])) |
|
|
alignment = 1 if vars[1] < vars[0] else 0 |
|
|
return res, mean_height, alignment |
