def compute_checkbox_position(blank_im):
binary = convert_to_binary(255 - blank_im)
labels, n = morph.label(binary)
h, w = binary.shape
minsize = 40
# find small dash in img
sums = measurements.sum(binary, labels, range(n + 1))
sums = sums[labels]
good = minimum(binary, 1 - (sums > 0) * (sums < minsize))
junk_cc = np.bitwise_xor(good, binary)
# temporary fix: add bottom line
junk_cc[h-1:, :] = np.ones((1, w))
junk_cc = morph.r_dilation(junk_cc, (7,7))
junk_cc = morph.r_closing(junk_cc, (9,9))
# find hole using morphology
hole = morph.fill_hole(junk_cc)
hole = hole - junk_cc
# locate holes position
labels, n = morph.label(hole)
objects = morph.find_objects(labels)
objects = sorted(objects, key=lambda b: sl.center(b))
area_thres = 0.4 * (amax([sl.area(b) for b in objects]) if len(objects) > 0 else 0)
boxes = [[b[0].start, b[1].start, b[0].stop, b[1].stop] for b in objects if sl.area(b) > area_thres]
return boxes, convert_binary_to_normal_im(hole)
def firstAnalyse(binary):
binaryary = morph.r_closing(binary.astype(bool), (1,1))
labels,_ = morph.label(binaryary)
objects = morph.find_objects(labels) ### <<<==== objects here
bysize = sorted(range(len(objects)), key=lambda k: sl.area(objects[k]))
# bysize = sorted(objects,key=sl.area)
scalemap = zeros(binaryary.shape)
smalldot = zeros(binaryary.shape, dtype=binary.dtype)
for i in bysize:
o = objects[i]
if amax(scalemap[o])>0:
# mask = where(labels[o] != (i+1),uint8(255),uint8(0))
# binary[o] = cv2.bitwise_and(binary[o],binary[o],mask=mask)
continue
scalemap[o] = sl.area(o)**0.5
scale = median(scalemap[(scalemap>3)&(scalemap<100)]) ### <<<==== scale here
for i,o in enumerate(objects):
if (sl.width(o) < scale/2) or (sl.height(o) < scale/2):
smalldot[o] = binary[o]
if sl.dim0(o) > 3*scale:
mask = where(labels[o] != (i+1),uint8(255),uint8(0))
binary[o] = cv2.bitwise_and(binary[o],binary[o],mask=mask)
continue
return objects, smalldot, scale
def compute_colseps_mconv(binary, scale=1.0):
"""Find column separators using a combination of morphological
operations and convolution."""
smoothed = gaussian_filter(1.0 * binary, (scale, scale * 0.5))
smoothed = uniform_filter(smoothed, (5.0 * scale, 1))
thresh = (smoothed < amax(smoothed) * 0.1)
blocks = morph.r_closing(binary, (int(4 * scale), int(4 * scale)))
seps = minimum(blocks, thresh)
seps = morph.select_regions(seps, sl.dim0, min=10 * scale, nbest=3)
blocks = morph.r_dilation(blocks, (5, 5))
seps = maximum(seps, 1 - blocks)
return seps
def simplefirstAnalyse(binary):
binaryary = morph.r_closing(binary.astype(bool), (1,1))
labels,_ = morph.label(binaryary)
objects = morph.find_objects(labels) ### <<<==== objects here
smalldot = zeros(binaryary.shape, dtype=binary.dtype)
scale = int(binary.shape[0]*0.7)
for i,o in enumerate(objects):
if (sl.width(o) < scale/2) or (sl.height(o) < scale/2):
smalldot[o] = binary[o]
if sl.dim0(o) > 3*scale:
mask = where(labels[o] != (i+1),uint8(255),uint8(0))
binary[o] = cv2.bitwise_and(binary[o],binary[o],mask=mask)
continue
return objects, smalldot, scale
def detect_table(image, scale, maxsize=10, debug_path=None):
h, w = image.shape[:2]
if len(image.shape) > 2 and image.shape[2] >= 3:
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
else:
gray = image
# kernel = np.ones((5,5),np.uint8)
# gray = 255-cv2.morphologyEx(255-gray, cv2.MORPH_CLOSE, kernel)
binary = 1 - morph.thresh_sauvola(gray, k=0.05)
junk_cc, _ = filter_junk_cc(binary, scale, maxsize)
junk_cc = morph.r_closing(junk_cc, (5, 5))
print('calculating combine sep...')
combine_sep = compute_combine_seps(junk_cc, scale)
# using closing morphology to connect disconnected edges
close_thes = int(scale * 0.15)
closed_sep = morph.r_closing(combine_sep, (close_thes, close_thes))
if debug_path is not None:
cv2.imwrite(filename[:-4] + '_bin.png',
((1 - junk_cc) * 255).astype('uint8'))
cv2.imwrite(filename[:-4] + '_sep.png',
(closed_sep * 255).astype('uint8'))
labels, _ = morph.label(closed_sep)
objects = morph.find_objects(labels)
# result table list
boxes = []
for i, b in enumerate(objects):
if sl.width(b) > maxsize * scale or sl.area(
b) > scale * scale * 10 or (sl.aspect_normalized(b) > 6
and sl.max_dim(b) > scale * 1.5):
density = np.sum(combine_sep[b])
density = density / sl.area(b)
if (sl.area(b) > scale * scale * 10 and sl.min_dim(b) > scale * 1.0
and sl.max_dim(b) > scale * 8 and density < 0.4):
# calculate projection to determine table border
w = sl.width(b)
h = sl.height(b)
region = (labels[b] == i + 1).astype('uint8')
border_pad = max(w, h)
border_thres = scale * 2
proj_x = np.sum(region, axis=0)
proj_y = np.sum(region, axis=1)
proj_x[3:] += proj_x[:-3]
proj_y[3:] += proj_y[:-3]
sep_x = np.sort([j[0] for j in np.argwhere(proj_x > 0.75 * h)])
sep_y = np.sort([j[0] for j in np.argwhere(proj_y > 0.4 * w)])
# skip if sep count < 2
if len(sep_x) < 1 or len(sep_y) < 1: continue
border_left, border_right, border_top, border_bottom = None, None, None, None
if sep_x[0] < border_pad:
border_left = sep_x[0]
if sep_x[-1] > w - border_pad:
border_right = sep_x[-1]
if sep_y[0] < border_pad:
border_top = sep_y[0]
if sep_y[-1] > h - border_pad:
border_bottom = sep_y[-1]
# print_info(border_top, border_bottom, border_left, border_right)
if all([
j is not None for j in
[border_top, border_bottom, border_left, border_right]
]):
border_right = b[1].stop - b[1].start
boxes.append([
b[1].start + border_left, b[0].start + border_top,
b[1].start + border_right, b[0].start + border_bottom
])
# boxes.append(([b[1].start, b[0].start, b[1].stop, b[0].stop]))
return boxes
def extractLines(imgpath, param):
img_grey = ocrolib.read_image_gray(imgpath)
(h, w) = img_grey.shape[:2]
img00 = cv2.resize(img_grey[h / 4:3 * h / 4, w / 4:3 * w / 4],
None,
fx=0.5,
fy=0.5)
angle = estimate_skew_angle(img00, linspace(-5, 5, 42))
print 'goc', angle
rotM = cv2.getRotationMatrix2D((w / 2, h / 2), angle, 1)
img_grey = cv2.warpAffine(img_grey, rotM, (w, h))
h, w = img_grey.shape
img_grey = cv2.normalize(img_grey.astype(float32), None, 0.0, 0.999,
cv2.NORM_MINMAX)
binary = sauvola(img_grey,
w=param.w,
k=param.k,
scaledown=0.2,
reverse=True) ### PARAM
binary = morph.r_closing(binary.astype(bool), (args.connect, 1))
binaryary = binary[h / 4:3 * h / 4, w / 4:3 * w / 4]
binary = binary.astype(np.uint8)
labels, n = morph.label(binaryary)
objects = morph.find_objects(labels)
bysize = sorted(objects, key=sl.area)
scalemap = zeros(binaryary.shape)
for o in bysize:
if amax(scalemap[o]) > 0: continue
scalemap[o] = sl.area(o)**0.5
scale = median(scalemap[(scalemap > 3) & (scalemap < 100)])
objects = psegutils.binary_objects(binary)
boxmap = zeros(binary.shape, dtype=np.uint8)
imgwidth = binary.shape[1]
imgheight = binary.shape[0]
cellwidth = 6 * scale
cellheight = 2.5 * scale
N_x = int(round(imgwidth / cellwidth))
cellwidth = int(round(imgwidth / N_x))
N_y = int(round(imgheight / cellheight))
cellheight = int(round(imgheight / N_y))
cells_list = [{}, {}, {}, {}]
def pixel2cell2id(pixel_x, pixel_y, CELLTYPE):
dx = 0
dy = 0
if CELLTYPE == 3:
pixel_x -= cellwidth / 2
pixel_y -= cellheight / 2
dx = cellwidth / 2
dy = cellheight / 2
if CELLTYPE == 2:
pixel_x -= cellwidth / 2
dx = cellwidth / 2
if CELLTYPE == 1:
pixel_y -= cellheight / 2
dy = cellheight / 2
if pixel_x <= 0 or pixel_y <= 0: return None, None
cellcoord = (pixel_x / cellwidth, pixel_y / cellheight)
cellid = cellcoord[0] + cellcoord[1] * N_x
cellcoord = (cellcoord[0] * cellwidth + dx,
cellcoord[1] * cellheight + dy)
return cellcoord, cellid
def id2cell2pixel(cellid, x, y, CELLTYPE):
cellcoord = (cellid % N_x, cellid / N_x)
pixel_x = cellcoord[0] * cellwidth + x
pixel_y = cellcoord[1] * cellheight + y
if CELLTYPE == 3:
pixel_x += cellwidth / 2
pixel_y += cellheight / 2
return cellcoord, pixel_x, pixel_y
img_grey = (cv2.cvtColor(img_grey, cv2.COLOR_GRAY2BGR) * 255).astype(
np.uint8)
for o in objects:
h = sl.dim0(o)
w = sl.dim1(o)
ratio = float(w) / h
### Dirty cheat
if ratio > 1 and ratio < 6:
recommended_width = max(int(0.6 * (o[0].stop - o[0].start)),
int(scale * 0.6), 5)
for pos in range(o[1].start + recommended_width, o[1].stop,
recommended_width):
binary[o[0].start:o[0].stop, pos:pos + 1] = np.uint8(0)
objects = psegutils.binary_objects(binary)
for o in objects:
h = sl.dim0(o)
w = sl.dim1(o)
a = h * w
# black = float(sum(binary[o]))/a
# if sl.area(o)**.5<threshold[0]*scale: continue
# if sl.area(o)**.5>threshold[1]*scale: continue
if h > 5 * scale: continue
# if h < 0.4*scale: continue
if w > 4 * scale and (h > 2 * scale or h < 0.5 * scale): continue
if a < 0.25 * scale * scale: continue
if float(h) / w > 10: continue
ratio = float(w) / h
if ratio > 10: continue
### Add object as candidate character
pixel_x, pixel_y = (o[1].start + o[1].stop) / 2, o[0].stop
for celltype in range(4):
cellcoord, cellid = pixel2cell2id(pixel_x,
pixel_y,
CELLTYPE=celltype)
if cellcoord is None or cellid is None: continue
cellbound = slice(cellcoord[1], cellcoord[1] + cellheight,
None), slice(cellcoord[0],
cellcoord[0] + cellwidth, None)
if cellid not in cells_list[celltype]:
cells_list[celltype][cellid] = SubLineFinder(
window_size=max(3, scale / 6),
cellbound=cellbound,
initChar=o)
else:
cells_list[celltype][cellid].addChar(o)
y0 = o[0].start
y1 = o[0].stop - 3 if o[0].stop - o[0].start > 8 else o[0].start + 5
x0 = o[1].start
x1 = o[1].stop - 3 if o[1].stop - o[1].start > 8 else o[1].start + 5
boxmap[y0:y1, x0:x1] = 1
for celltype in range(4):
if celltype == 0: col = (255, 0, 0)
if celltype == 1: col = (0, 255, 0)
if celltype == 2: col = (255, 255, 0)
if celltype == 3: col = (0, 0, 255)
for cellid, subline in cells_list[celltype].iteritems():
# cv2.rectangle(img_grey, (subline.cellbound[1].start+celltype, subline.cellbound[0].start+celltype), (subline.cellbound[1].stop+celltype, subline.cellbound[0].stop+celltype), col,1)
line = subline.subline()
if line is not None:
pos1 = (int(line[0][0]), int(line[0][1]))
pos2 = (int(line[1][0]), int(line[1][1]))
# print cellid, pos1, pos2
cv2.line(img_grey, pos1, pos2, col, 1)
### illustrate/debug first round
return binary, cv2.add(img_grey, (boxmap[:, :, np.newaxis] *
np.array([0, 50, 50])).astype(np.uint8))