# coding=utf-8
import math
from collections import Counter
import numpy as np
import cv2
from imutils import auto_canny, contours
from e import PolyNodeCountError
from score import score
from settings import CHOICES, SHEET_AREA_MIN_RATIO, PROCESS_BRIGHT_COLS, PROCESS_BRIGHT_ROWS, BRIGHT_VALUE, \
CHOICE_COL_COUNT, CHOICES_PER_QUE, WHITE_RATIO_PER_CHOICE, MAYBE_MULTI_CHOICE_THRESHOLD, CHOICE_CNT_COUNT, test_ans, \
ORIENT_CODE
def get_corner_node_list(poly_node_list):
"""
获得多边形四个顶点的坐标
:type poly_node_list: ndarray
:return: tuple
"""
center_y, center_x = (np.sum(poly_node_list, axis=0) / 4)[0]
top_left = bottom_left = top_right = bottom_right = None
for node in poly_node_list:
x = node[0, 1]
y = node[0, 0]
if x < center_x and y < center_y:
top_left = node
elif x < center_x and y > center_y:
bottom_left = node
elif x > center_x and y < center_y:
top_right = node
elif x > center_x and y > center_y:
bottom_right = node
return top_left, bottom_left, top_right, bottom_right
def detect_cnt_again(poly, base_img):
"""
继续检测已截取区域是否涵盖了答题卡区域
:param poly: ndarray
:param base_img: ndarray
:return: ndarray
"""
# 该多边形区域是否还包含答题卡区域的flag
flag = False
# 计算多边形四个顶点，并且截图，然后处理截取后的图片
top_left, bottom_left, top_right, bottom_right = get_corner_node_list(poly)
roi_img = get_roi_img(base_img, bottom_left, bottom_right, top_left, top_right)
img = get_init_process_img(roi_img)
# 获得面积最大的轮廓
cnt = get_max_area_cnt(img)
# 如果轮廓面积足够大，重新计算多边形四个顶点
if cv2.contourArea(cnt) > roi_img.shape[0] * roi_img.shape[1] * SHEET_AREA_MIN_RATIO:
flag = True
poly = cv2.approxPolyDP(cnt, cv2.arcLength((cnt,), True) * 0.1, True)
top_left, bottom_left, top_right, bottom_right = get_corner_node_list(poly)
if not poly.shape[0] == 4:
raise PolyNodeCountError
# 多边形顶点和图片顶点，主要用于纠偏
base_poly_nodes = np.float32([top_left[0], bottom_left[0], top_right[0], bottom_right[0]])
base_nodes = np.float32([[0, 0],
[base_img.shape[1], 0],
[0, base_img.shape[0]],
[base_img.shape[1], base_img.shape[0]]])
transmtx = cv2.getPerspectiveTransform(base_poly_nodes, base_nodes)
if flag:
img_warp = cv2.warpPerspective(roi_img, transmtx, (base_img.shape[1], base_img.shape[0]))
else:
img_warp = cv2.warpPerspective(base_img, transmtx, (base_img.shape[1], base_img.shape[0]))
return img_warp
def get_init_process_img(roi_img):
"""
对图片进行初始化处理，包括，梯度化，高斯模糊，二值化，腐蚀，膨胀和边缘检测
:param roi_img: ndarray
:return: ndarray
"""
h = cv2.Sobel(roi_img, cv2.CV_32F, 0, 1, -1)
v = cv2.Sobel(roi_img, cv2.CV_32F, 1, 0, -1)
img = cv2.add(h, v)
img = cv2.convertScaleAbs(img)
img = cv2.GaussianBlur(img, (3, 3), 0)
ret, img = cv2.threshold(img, 120, 255, cv2.THRESH_BINARY)
kernel = np.ones((1, 1), np.uint8)
img = cv2.erode(img, kernel, iterations=1)
img = cv2.dilate(img, kernel, iterations=2)
img = cv2.erode(img, kernel, iterations=1)
img = cv2.dilate(img, kernel, iterations=2)
img = auto_canny(img)
return img
def get_roi_img(base_img, bottom_left, bottom_right, top_left, top_right):
"""
截取合适的图片区域
:param base_img: ndarray
:param bottom_left: ndarray
:param bottom_right: ndarray
:param top_left: ndarray
:param top_right: ndarray
:return: ndarray
"""
min_v = top_left[0, 1] if top_left[0, 1] < bottom_left[0, 1] else bottom_left[0, 1]
max_v = top_right[0, 1] if top_right[0, 1] > bottom_right[0, 1] else bottom_right[0, 1]
min_h = top_left[0, 0] if top_left[0, 0] < top_right[0, 0] else top_right[0, 0]
max_h = bottom_left[0, 0] if bottom_left[0, 0] > bottom_right[0, 0] else bottom_right[0, 0]
roi_img = base_img[min_v + 10:max_v - 10, min_h + 10:max_h - 10]
return roi_img
def get_max_area_cnt(img):
"""
获得图片里面最大面积的轮廓
:param img: ndarray
:return: ndarray
"""
cnts, hierarchy = cv2.findContours(img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
cnt = max(cnts, key=lambda c: cv2.contourArea(c))
return cnt
def get_ans(ans_img, rows):
# 选项个数加上题号
interval = get_item_interval()
my_score = 0
items_per_row = get_items_per_row()
ans = []
for i, row in enumerate(rows):
# 从左到右为当前题目的气泡轮廓排序，然后初始化被涂画的气泡变量
for k in range(items_per_row):
print '======================================='
percent_list = []
for j, c in enumerate(row[1 + k * interval:interval + k * interval]):
try:
# 获得选项框的区域
new = ans_img[c[1]:(c[1] + c[3]), c[0]:(c[0] + c[2])]
# 计算白色像素个数和所占百分比
white_count = np.count_nonzero(new)
percent = white_count * 1.0 / new.size
except IndexError:
percent = 1
percent_list.append({'col': k + 1, 'row': i + 1, 'percent': percent, 'choice': CHOICES[j]})
percent_list.sort(key=lambda x: x['percent'])
choice_pos_n_ans = [percent_list[0]['row'], percent_list[0]['col']]
choice_pos = (percent_list[0]['row'], percent_list[0]['col'])
# if percent_list[1]['percent'] < 0.6 or (percent_list[1]['percent'] < WHITE_RATIO_PER_CHOICE and \
# abs(percent_list[1]['percent'] - percent_list[0]['percent']) < MAYBE_MULTI_CHOICE_THRESHOLD):
# print u'第%s排第%s列的作答：可能多涂了选项' % choice_pos
# print u"第%s排第%s列的作答：%s" % choice_pos_n_ans
# ans.append(percent_list[0]['choice'])
_ans = ''
for percent in percent_list:
if percent['percent'] < 0.8:
_ans += percent['choice']
ans.append(''.join(sorted(list(_ans))))
choice_pos_n_ans.append(''.join(sorted(list(_ans))))
print u'第{0}排第{1}列的作答：{2}'.format(*choice_pos_n_ans)
# elif percent_list[0]['percent'] < WHITE_RATIO_PER_CHOICE:
# # key = (percent_list[0]['row'] - 1) * 3 + percent_list[0]['col']
# # my_score += 1 if score.get(key) == percent_list[0]['choice'] else 0
# # print 1 if score.get(key) == percent_list[0]['choice'] else 0
# print u"第%s排第%s列的作答：%s" % choice_pos_n_ans
# print percent_list[0]['percent']
# ans.append(percent_list[0]['choice'])
# else:
# print u"第%s排第%s列的作答：可能没有填涂" % choice_pos
# print percent_list[0]['percent']
# ans.append(None)
print '=====总分========'
return rows, test_is_eq(ans, test_ans)
def test_is_eq(ans, test_ans):
count = 0
for i, a in enumerate(ans):
if a != test_ans[i]:
print i / 4 + 1, i % 4, a
count += 1
if count:
return False, count
return True, count
def get_items_per_row():
items_per_row = CHOICE_COL_COUNT / (CHOICES_PER_QUE + 1)
return items_per_row
def get_item_interval():
interval = CHOICES_PER_QUE + 1
return interval
def delete_rect(cents_pos, que_cnts):
count = 0
for i, c in enumerate(cents_pos):
area_ration = cv2.contourArea(que_cnts[i - count]) / (c[2] * c[3])
ratio = 1.0 * c[2] / c[3]
if 0.5 > ratio or ratio > 2 or area_ration < 0.5:
que_cnts.pop(i - count)
count += 1
return que_cnts
def get_left_right(cnts):
sort_res = contours.sort_contours(cnts, method="top-to-bottom")
cents_pos = sort_res[1]
que_cnts = list(sort_res[0])
que_cnts = delete_rect(cents_pos, que_cnts)
sort_res = contours.sort_contours(que_cnts, method="top-to-bottom")
cents_pos = sort_res[1]
que_cnts = list(sort_res[0])
num = len(cents_pos) - CHOICE_COL_COUNT + 1
dt = {}
for i in range(num):
distance = 0
for j in range(i, i + CHOICE_COL_COUNT - 1):
distance += cents_pos[j + 1][1] - cents_pos[j][1]
dt[distance] = cents_pos[i:i + CHOICE_COL_COUNT]
keys = dt.keys()
key_min = min(keys)
if key_min >= 10:
raise
w = sorted(dt[key_min], key=lambda x: x[0])
lt, rt = w[0][0] - w[0][2] * 0.5, w[-1][0] + w[-1][2] * 0.5
count = 0
for i, c in enumerate(cents_pos):
if c[0] < lt or c[0] > rt:
que_cnts.pop(i - count)
count += 1
return que_cnts
def get_top_bottom(cnts):
sort_res = contours.sort_contours(cnts, method="left-to-right")
cents_pos = sort_res[1]
que_cnts = list(sort_res[0])
choice_row_count = get_choice_row_count()
num = len(cents_pos) - choice_row_count + 1
dt = {}
for i in range(num):
distance = 0
for j in range(i, i + choice_row_count - 1):
distance += cents_pos[j + 1][0] - cents_pos[j][0]
dt[distance] = cents_pos[i:i + choice_row_count]
keys = dt.keys()
key_min = min(keys)
if key_min >= 10:
raise
w = sorted(dt[key_min], key=lambda x: x[1])
top, bottom = w[0][1] - w[0][3] * 0.5, w[-1][1] + w[-1][3] * 0.5
count = 0
for i, c in enumerate(cents_pos):
if c[1] < top or c[1] > bottom:
que_cnts.pop(i - count)
count += 1
return que_cnts
def get_choice_row_count():
choice_row_count = int(math.ceil(CHOICE_CNT_COUNT * 1.0 / CHOICE_COL_COUNT))
return choice_row_count
def sort_by_row(cnts_pos):
choice_row_count = get_choice_row_count()
count = 0
rows = []
threshold = get_min_row_interval(cnts_pos)
for i in range(choice_row_count):
cols = cnts_pos[i * CHOICE_COL_COUNT - count:(i + 1) * CHOICE_COL_COUNT - count]
# threshold = _std_plus_mean(cols)
temp_row = [cols[0]]
for j, col in enumerate(cols[1:]):
if col[1] - cols[j - 1][1] < threshold:
temp_row.append(col)
else:
break
count += CHOICE_COL_COUNT - len(temp_row)
temp_row.sort(key=lambda x: x[0])
rows.append(temp_row)
# insert_no_full_row(rows)
ck_full_rows_size(rows)
return rows
def sort_by_col(cnts_pos):
# TODO
cnts_pos.sort(key=lambda x: x[0])
choice_row_count = get_choice_row_count()
count = 0
cols = []
threshold = get_min_col_interval(cnts_pos)
for i in range(CHOICE_COL_COUNT):
rows = cnts_pos[i * choice_row_count - count:(i + 1) * choice_row_count - count]
temp_col = [rows[0]]
for j, row in enumerate(rows[1:]):
if row[0] - rows[j - 1][0] < threshold:
temp_col.append(row)
else:
break
count += choice_row_count - len(temp_col)
temp_col.sort(key=lambda x: x[1])
cols.append(temp_col)
ck_full_cols_size(cols)
return cols
def insert_null_2_rows(cols, rows):
temp = {}
for i, row in enumerate(rows):
for j, col in enumerate(cols):
try:
if row[j] != col[0]:
row.insert(j, (col[1][0], row[j][1], col[1][2], row[j][3]))
else:
temp[j] = col.pop(0)
except IndexError:
try:
row.insert(j, (col[1][0], row[j - 1][1], col[1][2], row[j - 1][3]))
except IndexError:
row.insert(j, (temp[j][0], row[j - 1][1], temp[j][2], row[j - 1][3]))
def get_min_row_interval(cnts_pos):
choice_row_count = get_choice_row_count()
rows_interval = []
for i, c in enumerate(cnts_pos[1:]):
rows_interval.append(c[1] - cnts_pos[i][1])
rows_interval.sort(reverse=True)
return min(rows_interval[:choice_row_count - 1])
def get_min_col_interval(cnts_pos):
cols_interval = []
for i, c in enumerate(cnts_pos[1:]):
cols_interval.append(c[0] - cnts_pos[i][0])
cols_interval.sort(reverse=True)
return min(cols_interval[:CHOICE_COL_COUNT - 1])
def get_min_interval(cnts_pos, orient):
idx = ORIENT_CODE[orient]
interval_list = []
def ck_full_rows_size(rows):
count = 0
for row in rows:
if len(row) == CHOICE_COL_COUNT:
count += 1
if count < 1:
raise
def ck_full_cols_size(rows):
choice_row_count = get_choice_row_count()
count = 0
for row in rows:
if len(row) == choice_row_count:
count += 1
if count < 1:
raise
def get_vertical_projective(img):
w = [0] * img.shape[1]
for x in range(img.shape[1]):
for y in range(img.shape[0]):
t = cv2.cv.Get2D(cv2.cv.fromarray(img), y, x)
if t[0] == 255:
w[x] += 1
# show_fuck(img, w)
seg(w, img)
return w
def get_h_projective(img):
h = [0] * img.shape[0]
for y in range(img.shape[0]):
for x in range(img.shape[1]):
s = cv2.cv.Get2D(cv2.cv.fromarray(img), y, x)
if s[0] == 255:
h[y] += 1
painty = np.zeros(img.shape, np.uint8)
painty = painty + 255
for y in range(img.shape[0]):
for x in range(h[y]):
cv2.cv.Set2D(cv2.cv.fromarray(painty), y, x, (0, 0, 0, 0))
cv2.imshow('painty', painty)
cv2.waitKey(0)
def show_fuck(img, w):
paintx = np.zeros(img.shape, np.uint8)
paintx = paintx + 255
for x in range(img.shape[1]):
for y in range(w[x]):
# 把为0的像素变成白
cv2.cv.Set2D(cv2.cv.fromarray(paintx), y, x, (0, 0, 0, 0))
# 显示图片
cv2.imshow('paintx', paintx)
cv2.waitKey(0)
def seg(w, img):
dt = Counter(w)
counts = np.array(dt.values())
mean = np.mean(counts)
std = np.std(counts)
_w = np.array(w)
_w[_w <= mean + std * 2] =0
count = 0
for i, _ in enumerate(_w[1:]):
if _ > 0 and _w[i] == 0:
count += 1
if _w[-1] > 0:
count -= 1
print count
if count != 18:
show_fuck(img, w)
show_fuck(img, _w)
print '1'
return _w
