def parse_rec(filename):
""" Parse a PASCAL VOC xml file """
import sys
reload(sys)
sys.setdefaultencoding('utf8')
tree = ET.parse(filename)
objects = []
for obj in tree.findall('object'):
obj_struct = {}
obj_struct['name'] = obj.find('name').text
#obj_struct['pose'] = obj.find('pose').text
obj_struct['truncated'] = int(obj.find('truncated').text)
obj_struct['difficult'] = int(obj.find('difficult').text)
bbox = obj.find('bndbox')
rbox = [
int(float(bbox.find('x1').text)),
int(float(bbox.find('y1').text)),
int(float(bbox.find('x2').text)),
int(float(bbox.find('y2').text)),
int(float(bbox.find('x3').text)),
int(float(bbox.find('y3').text)),
int(float(bbox.find('x4').text)),
int(float(bbox.find('y4').text)),
int(bbox.find('label').text)
]
rbox = np.array([rbox], np.float32)
rbox = coordinate_convert.back_forward_convert(rbox, with_label=True)
obj_struct['bbox'] = rbox
objects.append(obj_struct)
return objects
def parse_rec(filename):
""" Parse a PASCAL VOC xml file """
tree = ET.parse(filename)
objects = []
for obj in tree.findall('object'):
obj_struct = {}
obj_struct['name'] = obj.find('name').text
#obj_struct['pose'] = obj.find('pose').text
#obj_struct['truncated'] = int(obj.find('truncated').text)
#obj_struct['difficult'] = int(obj.find('difficult').text)
obj_struct['difficult'] = 0
bbox = obj.find('bndbox')
rbox = [
int(bbox.find('x1').text),
int(bbox.find('y1').text),
int(bbox.find('x2').text),
int(bbox.find('y2').text),
int(bbox.find('x3').text),
int(bbox.find('y3').text),
int(bbox.find('x4').text),
int(bbox.find('y4').text)
]
rbox = np.array([rbox], np.float32)
rbox = coordinate_convert.back_forward_convert(rbox, with_label=False)
obj_struct['bbox'] = rbox
objects.append(obj_struct)
return objects
def parse_rec_det_txt(detpath, filename, cls_name):
""" Parse a PASCAL infer txt file """
detfile = os.path.join(detpath, filename+".txt")
with open(detfile, 'r') as f:
lines = f.readlines()
boxes = []
for line in lines:
words = line.strip().split(',')
# print('words', words)
outside_points_num = 0
if words[8] == cls_name:
box = np.int0(np.array(words[0:8], dtype=np.float32))
box = list(coordinate_convert.back_forward_convert([box], False)[0])
box.insert(0, float(words[9]))
box.insert(0, filename)
boxes.append(box)
# print(boxes)
return(boxes)
def eval_with_plac(img_dir, det_net, image_ext, draw_imgs=False):
# 1. preprocess img
img_plac = tf.placeholder(dtype=tf.uint8, shape=[None, None,
3]) # is RGB. not GBR
img_batch = tf.cast(img_plac, tf.float32)
img_batch = img_batch - tf.constant(cfgs.PIXEL_MEAN)
img_batch = short_side_resize_for_inference_data(
img_tensor=img_batch,
target_shortside_len=cfgs.IMG_SHORT_SIDE_LEN,
is_resize=False)
det_boxes_r, det_scores_r, det_category_r = det_net.build_whole_detection_network(
input_img_batch=img_batch, gtboxes_h_batch=None, gtboxes_r_batch=None)
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
restorer, restore_ckpt = det_net.get_restorer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init_op)
if not restorer is None:
restorer.restore(sess, restore_ckpt)
print('restore model')
all_boxes_h = []
all_boxes_r = []
imgs = os.listdir(img_dir)
for i, a_img_name in enumerate(imgs):
a_img_name = a_img_name.split(image_ext)[0]
recs = {}
recs[a_img_name] = parse_rec(
os.path.join(test_annotation_path, a_img_name + '.xml'))
#R = [obj for obj in recs[a_img_name]]
bbox = np.squeeze(np.array([x['bbox'] for x in recs[a_img_name]]))
#labels = bbox[:, -1]
if len(bbox.shape) == 1:
bbox = np.expand_dims(bbox, axis=0)
labels = bbox[:, -1]
raw_img = cv2.imread(os.path.join(img_dir, a_img_name + image_ext))
raw_h, raw_w = raw_img.shape[0], raw_img.shape[1]
start = time.time()
resized_img, \
det_boxes_r_, det_scores_r_, det_category_r_ = \
sess.run(
[img_batch,
det_boxes_r, det_scores_r, det_category_r],
feed_dict={img_plac: raw_img}
)
end = time.time()
det_boxes_r_ = det_boxes_r_[det_scores_r_ >= 0.4]
det_category_r_ = det_category_r_[det_scores_r_ >= 0.4]
det_scores_r_ = det_scores_r_[det_scores_r_ >= 0.4]
keep = nms_rotate.nms_rotate_cpu(det_boxes_r_, det_scores_r_, 0.3,
20)
det_boxes_r_ = det_boxes_r_[keep]
det_scores_r_ = det_scores_r_[keep]
det_category_r_ = det_category_r_[keep]
##### box_ratio > 2 or < 1/2
index = (det_boxes_r_[:, 2] / det_boxes_r_[:, 3] >
2) | (det_boxes_r_[:, 2] / det_boxes_r_[:, 3] <= 0.5)
det_boxes_r_ = det_boxes_r_[index]
det_scores_r_ = det_scores_r_[index]
det_category_r_ = det_category_r_[index]
# print("{} cost time : {} ".format(img_name, (end - start)))
if draw_imgs:
det_detections_h = draw_box_in_img.draw_rotate_box_cv1(
np.squeeze(resized_img, 0),
boxes=bbox,
labels=labels,
scores=np.ones(bbox.shape[0]))
det_detections_r = draw_box_in_img.draw_rotate_box_cv(
np.squeeze(resized_img, 0),
boxes=det_boxes_r_,
labels=det_category_r_,
scores=det_scores_r_)
save_dir = os.path.join(cfgs.TEST_SAVE_PATH, cfgs.VERSION)
tools.mkdir(save_dir)
cv2.imwrite(save_dir + '/' + a_img_name + '_h.jpg',
det_detections_h[:, :, ::-1])
cv2.imwrite(save_dir + '/' + a_img_name + '_r.jpg',
det_detections_r[:, :, ::-1])
# xmin, ymin, xmax, ymax = det_boxes_h_[:, 0], det_boxes_h_[:, 1], \
# det_boxes_h_[:, 2], det_boxes_h_[:, 3]
if det_boxes_r_.shape[0] != 0:
resized_h, resized_w = resized_img.shape[1], resized_img.shape[
2]
det_boxes_r_ = forward_convert(det_boxes_r_, False)
det_boxes_r_[:, 0::2] *= (raw_w / resized_w)
det_boxes_r_[:, 1::2] *= (raw_h / resized_h)
det_boxes_r_ = back_forward_convert(det_boxes_r_, False)
x_c, y_c, w, h, theta = det_boxes_r_[:, 0], det_boxes_r_[:, 1], det_boxes_r_[:, 2], \
det_boxes_r_[:, 3], det_boxes_r_[:, 4]
# xmin = xmin * raw_w / resized_w
# xmax = xmax * raw_w / resized_w
# ymin = ymin * raw_h / resized_h
# ymax = ymax * raw_h / resized_h
# boxes_h = np.transpose(np.stack([xmin, ymin, xmax, ymax]))
boxes_r = np.transpose(np.stack([x_c, y_c, w, h, theta]))
# dets_h = np.hstack((det_category_h_.reshape(-1, 1),
# det_scores_h_.reshape(-1, 1),
# boxes_h))
dets_r = np.hstack((det_category_r_.reshape(-1, 1),
det_scores_r_.reshape(-1, 1), boxes_r))
# all_boxes_h.append(dets_h)
all_boxes_r.append(dets_r)
tools.view_bar(
'{} image cost {}s'.format(a_img_name, (end - start)), i + 1,
len(imgs))
fw1 = open(cfgs.VERSION + '_detections_h.pkl', 'w')
fw2 = open(cfgs.VERSION + '_detections_r.pkl', 'w')
pickle.dump(all_boxes_h, fw1)
pickle.dump(all_boxes_r, fw2)
def eval_with_plac(img_dir, det_net, num_imgs, image_ext, draw_imgs=False):
# 1. preprocess img
img_plac = tf.placeholder(dtype=tf.uint8, shape=[None, None, 3]) # is RGB. not GBR
img_batch = tf.cast(img_plac, tf.float32)
img_batch = img_batch - tf.constant(cfgs.PIXEL_MEAN)
img_batch = short_side_resize_for_inference_data(img_tensor=img_batch,
target_shortside_len=cfgs.IMG_SHORT_SIDE_LEN,
is_resize=False)
det_boxes_h, det_scores_h, det_category_h, \
det_boxes_r, det_scores_r, det_category_r = det_net.build_whole_detection_network(
input_img_batch=img_batch,
gtboxes_h_batch=None, gtboxes_r_batch=None)
init_op = tf.group(
tf.global_variables_initializer(),
tf.local_variables_initializer()
)
restorer, restore_ckpt = det_net.get_restorer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init_op)
if not restorer is None:
restorer.restore(sess, restore_ckpt)
print('restore model')
all_boxes_r = []
imgs = os.listdir(img_dir)
for i, a_img_name in enumerate(imgs):
a_img_name = a_img_name.split(image_ext)[0]
raw_img = cv2.imread(os.path.join(img_dir,
a_img_name + image_ext))
raw_h, raw_w = raw_img.shape[0], raw_img.shape[1]
start = time.time()
resized_img, det_boxes_r_, det_scores_r_, det_category_r_ = \
sess.run(
[img_batch, det_boxes_h, det_scores_h, det_category_h,
det_boxes_r, det_scores_r, det_category_r],
feed_dict={img_plac: raw_img}
)
end = time.time()
# print("{} cost time : {} ".format(img_name, (end - start)))
if draw_imgs:
det_detections_r = draw_box_in_img.draw_rotate_box_cv(np.squeeze(resized_img, 0),
boxes=det_boxes_r_,
labels=det_category_r_,
scores=det_scores_r_)
save_dir = os.path.join(cfgs.TEST_SAVE_PATH, cfgs.VERSION)
tools.mkdir(save_dir)
cv2.imwrite(save_dir + '/' + a_img_name + '_r.jpg',
det_detections_r[:, :, ::-1])
resized_h, resized_w = resized_img.shape[1], resized_img.shape[2]
det_boxes_r_ = forward_convert(det_boxes_r_, False)
det_boxes_r_[:, 0::2] *= (raw_w / resized_w)
det_boxes_r_[:, 1::2] *= (raw_h / resized_h)
det_boxes_r_ = back_forward_convert(det_boxes_r_, False)
x_c, y_c, w, h, theta = det_boxes_r_[:, 0], det_boxes_r_[:, 1], det_boxes_r_[:, 2], \
det_boxes_r_[:, 3], det_boxes_r_[:, 4]
boxes_r = np.transpose(np.stack([x_c, y_c, w, h, theta]))
dets_r = np.hstack((det_category_r_.reshape(-1, 1),
det_scores_r_.reshape(-1, 1),
boxes_r))
all_boxes_r.append(dets_r)
tools.view_bar('{} image cost {}s'.format(a_img_name, (end - start)), i + 1, len(imgs))
fw2 = open(cfgs.VERSION + '_detections_r.pkl', 'w')
pickle.dump(all_boxes_r, fw2)
def inference(det_net, file_paths, des_folder, h_len, w_len, h_overlap, w_overlap, save_res=False):
if save_res:
assert cfgs.SHOW_SCORE_THRSHOLD >= 0.5, \
'please set score threshold (example: SHOW_SCORE_THRSHOLD = 0.5) in cfgs.py'
else:
assert cfgs.SHOW_SCORE_THRSHOLD < 0.005, \
'please set score threshold (example: SHOW_SCORE_THRSHOLD = 0.00) in cfgs.py'
# 1. preprocess img
img_plac = tf.placeholder(dtype=tf.uint8, shape=[None, None, 3])
img_batch = tf.cast(img_plac, tf.float32)
img_batch = img_batch - tf.constant(cfgs.PIXEL_MEAN)
img_batch = short_side_resize_for_inference_data(img_tensor=img_batch,
target_shortside_len=cfgs.IMG_SHORT_SIDE_LEN[0],
is_resize=False)
det_boxes_h, det_scores_h, det_category_h, \
det_boxes_r, det_scores_r, det_category_r = det_net.build_whole_detection_network(input_img_batch=img_batch,
gtboxes_h_batch=None,
gtboxes_r_batch=None,
mask_batch=None)
init_op = tf.group(
tf.global_variables_initializer(),
tf.local_variables_initializer()
)
restorer, restore_ckpt = det_net.get_restorer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init_op)
if not restorer is None:
restorer.restore(sess, restore_ckpt)
print('restore model')
if not os.path.exists('./tmp.txt'):
fw = open('./tmp.txt', 'w')
fw.close()
fr = open('./tmp.txt', 'r')
pass_img = fr.readlines()
fr.close()
for count, img_path in enumerate(file_paths):
fw = open('./tmp.txt', 'a+')
if img_path + '\n' in pass_img:
continue
start = timer()
img = cv2.imread(img_path)
box_res = []
label_res = []
score_res = []
box_res_rotate = []
label_res_rotate = []
score_res_rotate = []
imgH = img.shape[0]
imgW = img.shape[1]
if imgH < h_len:
temp = np.zeros([h_len, imgW, 3], np.float32)
temp[0:imgH, :, :] = img
img = temp
imgH = h_len
if imgW < w_len:
temp = np.zeros([imgH, w_len, 3], np.float32)
temp[:, 0:imgW, :] = img
img = temp
imgW = w_len
for hh in range(0, imgH, h_len - h_overlap):
if imgH - hh - 1 < h_len:
hh_ = imgH - h_len
else:
hh_ = hh
for ww in range(0, imgW, w_len - w_overlap):
if imgW - ww - 1 < w_len:
ww_ = imgW - w_len
else:
ww_ = ww
src_img = img[hh_:(hh_ + h_len), ww_:(ww_ + w_len), :]
for ss in cfgs.IMG_SHORT_SIDE_LEN:
img_resize = cv2.resize(src_img, (ss, ss))
det_boxes_h_, det_scores_h_, det_category_h_, \
det_boxes_r_, det_scores_r_, det_category_r_ = \
sess.run(
[det_boxes_h, det_scores_h, det_category_h,
det_boxes_r, det_scores_r, det_category_r],
feed_dict={img_plac: img_resize[:, :, ::-1]}
)
det_boxes_h_[:, 0] = det_boxes_h_[:, 0] * w_len / ss
det_boxes_h_[:, 1] = det_boxes_h_[:, 1] * h_len / ss
det_boxes_h_[:, 2] = det_boxes_h_[:, 2] * w_len / ss
det_boxes_h_[:, 3] = det_boxes_h_[:, 3] * h_len / ss
det_boxes_r_ = forward_convert(det_boxes_r_, False)
det_boxes_r_[:, 0::2] *= (w_len / ss)
det_boxes_r_[:, 1::2] *= (h_len / ss)
det_boxes_r_ = back_forward_convert(det_boxes_r_, False)
# det_boxes_r_[:, 0] = det_boxes_r_[:, 0] * w_len / ss
# det_boxes_r_[:, 1] = det_boxes_r_[:, 1] * h_len / ss
# det_boxes_r_[:, 2] = det_boxes_r_[:, 2] * w_len / ss
# det_boxes_r_[:, 3] = det_boxes_r_[:, 3] * h_len / ss
if len(det_boxes_h_) > 0:
for ii in range(len(det_boxes_h_)):
box = det_boxes_h_[ii]
box[0] = box[0] + ww_
box[1] = box[1] + hh_
box[2] = box[2] + ww_
box[3] = box[3] + hh_
box_res.append(box)
label_res.append(det_category_h_[ii])
score_res.append(det_scores_h_[ii])
if len(det_boxes_r_) > 0:
for ii in range(len(det_boxes_r_)):
box_rotate = det_boxes_r_[ii]
box_rotate[0] = box_rotate[0] + ww_
box_rotate[1] = box_rotate[1] + hh_
box_res_rotate.append(box_rotate)
label_res_rotate.append(det_category_r_[ii])
score_res_rotate.append(det_scores_r_[ii])
box_res = np.array(box_res)
label_res = np.array(label_res)
score_res = np.array(score_res)
box_res_rotate = np.array(box_res_rotate)
label_res_rotate = np.array(label_res_rotate)
score_res_rotate = np.array(score_res_rotate)
box_res_rotate_, label_res_rotate_, score_res_rotate_ = [], [], []
box_res_, label_res_, score_res_ = [], [], []
r_threshold = {'roundabout': 0.1, 'tennis-court': 0.3, 'swimming-pool': 0.1, 'storage-tank': 0.2,
'soccer-ball-field': 0.3, 'small-vehicle': 0.2, 'ship': 0.05, 'plane': 0.3,
'large-vehicle': 0.1, 'helicopter': 0.2, 'harbor': 0.0001, 'ground-track-field': 0.3,
'bridge': 0.0001, 'basketball-court': 0.3, 'baseball-diamond': 0.3}
h_threshold = {'roundabout': 0.35, 'tennis-court': 0.35, 'swimming-pool': 0.4, 'storage-tank': 0.3,
'soccer-ball-field': 0.3, 'small-vehicle': 0.4, 'ship': 0.35, 'plane': 0.35,
'large-vehicle': 0.4, 'helicopter': 0.4, 'harbor': 0.3, 'ground-track-field': 0.4,
'bridge': 0.3, 'basketball-court': 0.4, 'baseball-diamond': 0.3}
for sub_class in range(1, cfgs.CLASS_NUM + 1):
index = np.where(label_res_rotate == sub_class)[0]
if len(index) == 0:
continue
tmp_boxes_r = box_res_rotate[index]
tmp_label_r = label_res_rotate[index]
tmp_score_r = score_res_rotate[index]
tmp_boxes_r = np.array(tmp_boxes_r)
tmp = np.zeros([tmp_boxes_r.shape[0], tmp_boxes_r.shape[1] + 1])
tmp[:, 0:-1] = tmp_boxes_r
tmp[:, -1] = np.array(tmp_score_r)
try:
inx = nms_rotate.nms_rotate_cpu(boxes=np.array(tmp_boxes_r),
scores=np.array(tmp_score_r),
iou_threshold=r_threshold[LABEL_NAME_MAP[sub_class]],
max_output_size=500)
except:
# Note: the IoU of two same rectangles is 0, which is calculated by rotate_gpu_nms
jitter = np.zeros([tmp_boxes_r.shape[0], tmp_boxes_r.shape[1] + 1])
jitter[:, 0] += np.random.rand(tmp_boxes_r.shape[0], ) / 1000
inx = rotate_gpu_nms(np.array(tmp, np.float32) + np.array(jitter, np.float32),
float(r_threshold[LABEL_NAME_MAP[sub_class]]), 0)
box_res_rotate_.extend(np.array(tmp_boxes_r)[inx])
score_res_rotate_.extend(np.array(tmp_score_r)[inx])
label_res_rotate_.extend(np.array(tmp_label_r)[inx])
for sub_class in range(1, cfgs.CLASS_NUM + 1):
index = np.where(label_res == sub_class)[0]
if len(index) == 0:
continue
tmp_boxes_h = box_res[index]
tmp_label_h = label_res[index]
tmp_score_h = score_res[index]
tmp_boxes_h = np.array(tmp_boxes_h)
tmp = np.zeros([tmp_boxes_h.shape[0], tmp_boxes_h.shape[1] + 1])
tmp[:, 0:-1] = tmp_boxes_h
tmp[:, -1] = np.array(tmp_score_h)
inx = nms.py_cpu_nms(dets=np.array(tmp, np.float32),
thresh=h_threshold[LABEL_NAME_MAP[sub_class]],
max_output_size=500)
box_res_.extend(np.array(tmp_boxes_h)[inx])
score_res_.extend(np.array(tmp_score_h)[inx])
label_res_.extend(np.array(tmp_label_h)[inx])
time_elapsed = timer() - start
if save_res:
det_detections_h = draw_box_in_img.draw_box_cv(np.array(img, np.float32) - np.array(cfgs.PIXEL_MEAN),
boxes=np.array(box_res_),
labels=np.array(label_res_),
scores=np.array(score_res_))
det_detections_r = draw_box_in_img.draw_rotate_box_cv(
np.array(img, np.float32) - np.array(cfgs.PIXEL_MEAN),
boxes=np.array(box_res_rotate_),
labels=np.array(label_res_rotate_),
scores=np.array(score_res_rotate_))
save_dir = os.path.join(des_folder, cfgs.VERSION)
tools.mkdir(save_dir)
cv2.imwrite(save_dir + '/' + img_path.split('/')[-1].split('.')[0] + '_h.jpg',
det_detections_h)
cv2.imwrite(save_dir + '/' + img_path.split('/')[-1].split('.')[0] + '_r.jpg',
det_detections_r)
view_bar('{} cost {}s'.format(img_path.split('/')[-1].split('.')[0],
time_elapsed), count + 1, len(file_paths))
else:
# eval txt
CLASS_DOTA = NAME_LABEL_MAP.keys()
# Task1
write_handle_r = {}
write_handle_h_ = {}
txt_dir_r = os.path.join('txt_output', cfgs.VERSION + '_r_pyramid')
txt_dir_h_minAreaRect = os.path.join('txt_output', cfgs.VERSION + '_h_minAreaRect_pyramid')
tools.mkdir(txt_dir_r)
tools.mkdir(txt_dir_h_minAreaRect)
for sub_class in CLASS_DOTA:
if sub_class == 'back_ground':
continue
write_handle_r[sub_class] = open(os.path.join(txt_dir_r, 'Task1_%s.txt' % sub_class), 'a+')
write_handle_h_[sub_class] = open(os.path.join(txt_dir_h_minAreaRect, 'Task2_%s.txt' % sub_class), 'a+')
rboxes = coordinate_convert.forward_convert(box_res_rotate_, with_label=False)
for i, rbox in enumerate(rboxes):
command = '%s %.3f %.1f %.1f %.1f %.1f %.1f %.1f %.1f %.1f\n' % (img_path.split('/')[-1].split('.')[0],
score_res_rotate_[i],
rbox[0], rbox[1], rbox[2], rbox[3],
rbox[4], rbox[5], rbox[6], rbox[7],)
command_ = '%s %.3f %.1f %.1f %.1f %.1f\n' % (img_path.split('/')[-1].split('.')[0],
score_res_rotate_[i],
min(rbox[::2]), min(rbox[1::2]),
max(rbox[::2]), max(rbox[1::2]))
write_handle_r[LABEL_NAME_MAP[label_res_rotate_[i]]].write(command)
write_handle_h_[LABEL_NAME_MAP[label_res_rotate_[i]]].write(command_)
for sub_class in CLASS_DOTA:
if sub_class == 'back_ground':
continue
write_handle_r[sub_class].close()
# Task2
write_handle_h = {}
txt_dir_h = os.path.join('txt_output', cfgs.VERSION + '_h_pyramid')
tools.mkdir(txt_dir_h)
for sub_class in CLASS_DOTA:
if sub_class == 'back_ground':
continue
write_handle_h[sub_class] = open(os.path.join(txt_dir_h, 'Task2_%s.txt' % sub_class), 'a+')
for i, hbox in enumerate(box_res_):
command = '%s %.3f %.1f %.1f %.1f %.1f\n' % (img_path.split('/')[-1].split('.')[0],
score_res_[i],
hbox[0], hbox[1], hbox[2], hbox[3])
write_handle_h[LABEL_NAME_MAP[label_res_[i]]].write(command)
for sub_class in CLASS_DOTA:
if sub_class == 'back_ground':
continue
write_handle_h[sub_class].close()
view_bar('{} cost {}s'.format(img_path.split('/')[-1].split('.')[0],
time_elapsed), count + 1, len(file_paths))
fw.write('{}\n'.format(img_path))
fw.close()
os.remove('./tmp.txt')
def eval_with_plac(img_dir, det_net, num_imgs, image_ext, draw_imgs,
test_annotation_path):
# 1. preprocess img
img_plac = tf.placeholder(dtype=tf.uint8, shape=[None, None,
3]) # is RGB. not GBR
img_batch = tf.cast(img_plac, tf.float32)
img_batch = img_batch - tf.constant(cfgs.PIXEL_MEAN)
img_batch = short_side_resize_for_inference_data(
img_tensor=img_batch,
target_shortside_len=cfgs.IMG_SHORT_SIDE_LEN,
is_resize=False)
det_boxes_h, det_scores_h, det_category_h, \
det_boxes_r, det_scores_r, det_category_r = det_net.build_whole_detection_network(
input_img_batch=img_batch,
gtboxes_h_batch=None, gtboxes_r_batch=None)
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
global_step_tensor = slim.get_or_create_global_step()
eval_result = []
last_checkpoint_name = None
while True:
restorer, restore_ckpt = det_net.get_restorer()
#saver = tf.train.Saver(max_to_keep=10)
start_time = time.time()
model_path = os.path.splitext(os.path.basename(restore_ckpt))[0]
if model_path == None:
print("Wait for available checkpoint")
elif last_checkpoint_name == model_path:
print(
"Already evaluated checkpoint {}, we will try evaluation in {} seconds"
.format(model_path, EVAL_INTERVAL))
#continue
else:
print('Last ckpt was {}, new ckpt is {}'.format(
last_checkpoint_name, model_path))
last_checkpoint_name = model_path
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init_op)
sess.run(global_step_tensor.initializer)
if not restorer is None:
restorer.restore(sess, restore_ckpt)
print('restore model', restore_ckpt)
global_stepnp = tf.train.global_step(sess, global_step_tensor)
print('#########################', global_stepnp)
all_boxes_h = []
all_boxes_r = []
imgs = os.listdir(img_dir)
imgs_len = len(imgs)
none_detected_image = []
for i, a_img_name in enumerate(imgs[:]):
a_img_name = a_img_name.split(image_ext)[0]
image_name = a_img_name + image_ext
print('\n', a_img_name)
raw_img = cv2.imread(
os.path.join(img_dir, a_img_name + image_ext))
raw_h, raw_w = raw_img.shape[0], raw_img.shape[1]
start = time.time()
resized_img, det_boxes_h_, det_scores_h_, det_category_h_, \
det_boxes_r_, det_scores_r_, det_category_r_ = \
sess.run(
[img_batch, det_boxes_h, det_scores_h, det_category_h,
det_boxes_r, det_scores_r, det_category_r],
feed_dict={img_plac: raw_img}
)
end = time.time()
print("det category H : ", det_category_h_)
print("det category R : ", det_category_r_)
# print("{} cost time : {} ".format(img_name, (end - start)))
if draw_imgs:
det_detections_h = draw_box_in_img.draw_box_cv(
np.squeeze(resized_img, 0),
boxes=det_boxes_h_,
labels=det_category_h_,
scores=det_scores_h_)
det_detections_r = draw_box_in_img.draw_rotate_box_cv(
np.squeeze(resized_img, 0),
boxes=det_boxes_r_,
labels=det_category_r_,
scores=det_scores_r_)
save_dir = os.path.join(cfgs.TEST_SAVE_PATH,
cfgs.VERSION)
tools.mkdir(save_dir)
cv2.imwrite(save_dir + '/' + a_img_name + '_h.jpg',
det_detections_h[:, :, ::-1])
cv2.imwrite(save_dir + '/' + a_img_name + '_r.jpg',
det_detections_r[:, :, ::-1])
xmin, ymin, xmax, ymax = det_boxes_h_[:, 0], det_boxes_h_[:, 1], \
det_boxes_h_[:, 2], det_boxes_h_[:, 3]
if det_boxes_r_.shape[0] != 0:
#print('### Has box ###')
resized_h, resized_w = resized_img.shape[
1], resized_img.shape[2]
det_boxes_r_ = forward_convert(det_boxes_r_, False)
det_boxes_r_[:, 0::2] *= (raw_w / resized_w)
det_boxes_r_[:, 1::2] *= (raw_h / resized_h)
det_boxes_r_ = back_forward_convert(
det_boxes_r_, False)
x_c, y_c, w, h, theta = det_boxes_r_[:, 0], det_boxes_r_[:, 1], det_boxes_r_[:, 2], \
det_boxes_r_[:, 3], det_boxes_r_[:, 4]
xmin = xmin * raw_w / resized_w
xmax = xmax * raw_w / resized_w
ymin = ymin * raw_h / resized_h
ymax = ymax * raw_h / resized_h
boxes_h = np.transpose(
np.stack([xmin, ymin, xmax, ymax]))
boxes_r = np.transpose(
np.stack([x_c, y_c, w, h, theta]))
dets_h = np.hstack((det_category_h_.reshape(-1, 1),
det_scores_h_.reshape(-1,
1), boxes_h))
dets_r = np.hstack((det_category_r_.reshape(-1, 1),
det_scores_r_.reshape(-1,
1), boxes_r))
all_boxes_h.append(dets_h)
all_boxes_r.append(dets_r)
else:
imgs.remove(image_name)
none_detected_image.append(image_name)
print('No detected')
tools.view_bar(
'{} image cost {}s'.format(a_img_name, (end - start)),
i + 1, imgs_len)
fw1 = open(cfgs.VERSION + '_detections_h.pkl', 'wb')
fw2 = open(cfgs.VERSION + '_detections_r.pkl', 'wb')
pickle.dump(all_boxes_h, fw1)
pickle.dump(all_boxes_r, fw2)
# with open(cfgs.VERSION + '_detections_h.pkl', 'rb') as f1:
# all_boxes_h = pickle.load(f1, encoding='unicode')
# print(10 * "###")
# print(len(all_boxes_h))
#
# with open(cfgs.VERSION + '_detections_r.pkl', 'rb') as f2:
# all_boxes_r = pickle.load(f2, encoding='unicode')
#
# print(len(all_boxes_r))
# imgs = os.listdir(img_dir)
real_test_imgname_list = [i.split(image_ext)[0] for i in imgs]
print(10 * "**")
print('horizon eval:')
# print(len(all_boxes_h), len(all_boxes_r))
# print(len(real_test_imgname_list))
mAP_h, recall_h, precision_h, total_mAP_h, total_recall_h, total_precision_h = voc_eval.voc_evaluate_detections(
all_boxes=all_boxes_h,
test_imgid_list=real_test_imgname_list,
test_annotation_path=test_annotation_path)
print('mAP_h: ', mAP_h)
print('mRecall_h:', recall_h)
print('mPrecision_h:', precision_h)
print('total_mAP_h: ', total_mAP_h)
print('total_recall_h_list:', total_recall_h)
print('total_precision_h_list:', total_precision_h)
print(10 * "**")
print('rotation eval:')
mAP_r, recall_r, precision_r, total_mAP_r, total_recall_r, total_precision_r = voc_eval_r.voc_evaluate_detections(
all_boxes=all_boxes_r,
test_imgid_list=real_test_imgname_list,
test_annotation_path=test_annotation_path)
f1score_h_check = (1 + 1**2) * precision_h * recall_h / (
1**2 * precision_h + recall_h)
f1score_h = calc_fscore(precision_h, recall_h, 1)
f1score_r_check = (1 + 1**2) * precision_r * recall_r / (
1**2 * precision_r + recall_r)
f1score_r = calc_fscore(precision_r, recall_r, 1)
print(10 * '##')
print('mAP_r:', mAP_r)
print('mRecall_r:', recall_r)
print('mPrecision_r:', precision_r)
print('total_mAP_r_list: ', total_mAP_r)
print('total_recall_r_list:', total_recall_r)
print('total_precision_r_list:', total_precision_r)
print('f1score_r:', f1score_r)
summary_path = os.path.join(cfgs.SUMMARY_PATH,
cfgs.VERSION + '/eval_0')
tools.mkdir(summary_path)
summary_writer = tf.summary.FileWriter(summary_path,
graph=sess.graph)
mAP_h_summ = tf.Summary()
mAP_h_summ.value.add(tag='EVAL_Global/mAP_h',
simple_value=mAP_h)
summary_writer.add_summary(mAP_h_summ, global_stepnp)
mAP_r_summ = tf.Summary()
mAP_r_summ.value.add(tag='EVAL_Global/mAP_r',
simple_value=mAP_r)
summary_writer.add_summary(mAP_r_summ, global_stepnp)
mRecall_h_summ = tf.Summary()
mRecall_h_summ.value.add(tag='EVAL_Global/Recall_h',
simple_value=recall_h)
summary_writer.add_summary(mRecall_h_summ, global_stepnp)
mRecall_r_summ = tf.Summary()
mRecall_r_summ.value.add(tag='EVAL_Global/Recall_r',
simple_value=recall_r)
summary_writer.add_summary(mRecall_r_summ, global_stepnp)
mPrecision_h_summ = tf.Summary()
mPrecision_h_summ.value.add(tag='EVAL_Global/Precision_h',
simple_value=precision_h)
summary_writer.add_summary(mPrecision_h_summ, global_stepnp)
mPrecision_r_summ = tf.Summary()
mPrecision_r_summ.value.add(tag='EVAL_Global/Precision_r',
simple_value=precision_r)
summary_writer.add_summary(mPrecision_r_summ, global_stepnp)
mF1Score_h_summ = tf.Summary()
mF1Score_h_summ.value.add(tag='EVAL_Global/F1Score_h',
simple_value=f1score_h)
summary_writer.add_summary(mF1Score_h_summ, global_stepnp)
mF1Score_r_summ = tf.Summary()
mF1Score_r_summ.value.add(tag='EVAL_Global/F1Score_r',
simple_value=f1score_r)
summary_writer.add_summary(mF1Score_r_summ, global_stepnp)
mAP_h_class_dict = {}
mAP_r_class_dict = {}
recall_h_class_dict = {}
recall_r_class_dict = {}
precision_h_class_dict = {}
precision_r_class_dict = {}
f1score_h_class_dict = {}
f1score_r_class_dict = {}
label_list = list(NAME_LABEL_MAP.keys())
label_list.remove('back_ground')
for cls in label_list:
mAP_h_class_dict["cls_%s_mAP_h_summ" % cls] = tf.Summary()
mAP_r_class_dict["cls_%s_mAP_r_summ" % cls] = tf.Summary()
recall_h_class_dict["cls_%s_recall_h_summ" %
cls] = tf.Summary()
recall_r_class_dict["cls_%s_recall_r_summ" %
cls] = tf.Summary()
precision_h_class_dict["cls_%s_precision_h_summ" %
cls] = tf.Summary()
precision_r_class_dict["cls_%s_precision_r_summ" %
cls] = tf.Summary()
f1score_h_class_dict["cls_%s_f1score_h_summ" %
cls] = tf.Summary()
f1score_r_class_dict["cls_%s_f1score_r_summ" %
cls] = tf.Summary()
for cls in label_list:
mAP_h_class_dict["cls_%s_mAP_h_summ" % cls].value.add(
tag='EVAL_Class_mAP/{}_mAP_h'.format(cls),
simple_value=total_mAP_h[cls])
mAP_r_class_dict["cls_%s_mAP_r_summ" % cls].value.add(
tag='EVAL_Class_mAP/{}_mAP_r'.format(cls),
simple_value=total_mAP_r[cls])
recall_h_class_dict[
"cls_%s_recall_h_summ" % cls].value.add(
tag='EVAL_Class_recall/{}_recall_h'.format(cls),
simple_value=total_recall_h[cls])
recall_r_class_dict[
"cls_%s_recall_r_summ" % cls].value.add(
tag='EVAL_Class_recall/{}_recall_r'.format(cls),
simple_value=total_recall_r[cls])
precision_h_class_dict[
"cls_%s_precision_h_summ" % cls].value.add(
tag='EVAL_Class_precision/{}_precision_h'.format(
cls),
simple_value=total_precision_h[cls])
precision_r_class_dict[
"cls_%s_precision_r_summ" % cls].value.add(
tag='EVAL_Class_precision/{}_precision_r'.format(
cls),
simple_value=total_precision_r[cls])
f1score_h_cls = calc_fscore(total_precision_h[cls],
total_recall_h[cls], 1)
f1score_r_cls = calc_fscore(total_precision_r[cls],
total_recall_r[cls], 1)
f1score_h_class_dict[
"cls_%s_f1score_h_summ" % cls].value.add(
tag='EVAL_Class_f1score/{}_f1score_h'.format(cls),
simple_value=f1score_h_cls)
f1score_r_class_dict[
"cls_%s_f1score_r_summ" % cls].value.add(
tag='EVAL_Class_f1score/{}_f1score_r'.format(cls),
simple_value=f1score_r_cls)
for cls in label_list:
summary_writer.add_summary(
mAP_h_class_dict["cls_%s_mAP_h_summ" % cls],
global_stepnp)
summary_writer.add_summary(
mAP_r_class_dict["cls_%s_mAP_r_summ" % cls],
global_stepnp)
summary_writer.add_summary(
recall_h_class_dict["cls_%s_recall_h_summ" % cls],
global_stepnp)
summary_writer.add_summary(
recall_r_class_dict["cls_%s_recall_r_summ" % cls],
global_stepnp)
summary_writer.add_summary(
precision_h_class_dict["cls_%s_precision_h_summ" %
cls], global_stepnp)
summary_writer.add_summary(
precision_r_class_dict["cls_%s_precision_r_summ" %
cls], global_stepnp)
summary_writer.add_summary(
f1score_h_class_dict["cls_%s_f1score_h_summ" % cls],
global_stepnp)
summary_writer.add_summary(
f1score_r_class_dict["cls_%s_f1score_r_summ" % cls],
global_stepnp)
summary_writer.flush()
if not os.path.exists(save_dir):
os.makedirs(save_dir)
save_ckpt = os.path.join(save_dir,
'voc_' + str(global_stepnp) + 'model.ckpt')
#saver.save(sess, save_ckpt)
print(' weights had been saved')
time_to_next_eval = start_time + EVAL_INTERVAL - time.time()
if time_to_next_eval > 0:
time.sleep(time_to_next_eval)