def main_inference(model_json, model_weights, num_stack, num_class, imgfile, confth, tiny):
if tiny:
xnet = HourglassNet(num_classes=16, num_stacks=args.num_stack, num_channels=128, inres=(192, 192),
outres=(48, 48))
else:
xnet = HourglassNet(num_classes=16, num_stacks=args.num_stack, num_channels=256, inres=(256, 256),
outres=(64, 64))
xnet.load_model(model_json, model_weights)
out, scale = xnet.inference_file(imgfile)
kps = post_process_heatmap(out[0, :, :, :])
ignore_kps = ['plevis', 'thorax', 'head_top']
kp_keys = MPIIDataGen.get_kp_keys()
mkps = list()
for i, _kp in enumerate(kps):
if kp_keys[i] in ignore_kps:
_conf = 0.0
else:
_conf = _kp[2]
mkps.append((_kp[0] * scale[1] * 4, _kp[1] * scale[0] * 4, _conf))
cvmat = render_joints(cv2.imread(imgfile), mkps, confth)
cv2.imshow('frame', cvmat)
cv2.waitKey()
def main_video(model_json, model_weights, num_stack, num_class, videofile,
confth):
xnet = HourglassNet(num_class, num_stack, (256, 256), (64, 64))
xnet.load_model(model_json, model_weights)
cap = cv2.VideoCapture(videofile)
while (cap.isOpened()):
ret, frame = cap.read()
if ret:
rgb = frame[:, :, ::-1] # bgr -> rgb
out, scale = xnet.inference_rgb(rgb, frame.shape)
kps = post_process_heatmap(out[0, :, :, :])
ignore_kps = ['plevis', 'thorax', 'head_top']
kp_keys = MPIIDataGen.get_kp_keys()
mkps = list()
for i, _kp in enumerate(kps):
if kp_keys[i] in ignore_kps:
_conf = 0.0
else:
_conf = _kp[2]
mkps.append(
(_kp[0] * scale[1] * 4, _kp[1] * scale[0] * 4, _conf))
framejoints = render_joints(frame, mkps, confth)
cv2.imshow('frame', framejoints)
cv2.waitKey(10)
def get_predicted_kp_from_htmap(heatmap, meta):
# nms to get location
kplst = post_process_heatmap(heatmap)
kps = np.array(kplst)
# use meta information to transform back to original image
mkps = copy.copy(kps)
for i in range(kps.shape[0]):
mkps[i, 0:2] = data_process.transform(kps[i], meta['center'], meta['scale'], res=[64, 64], invert=1, rot=0)
return mkps
def heatmap_accuracy(predhmap, meta, norm, threshold):
pred_kps = post_process_heatmap(predhmap)
pred_kps = np.array(pred_kps)
gt_kps = meta['tpts']
good_pred_count = 0
failed_pred_count = 0
for i in range(gt_kps.shape[0]):
dis = cal_kp_distance(pred_kps[i, :], gt_kps[i, :], norm, threshold)
if dis == 0:
failed_pred_count += 1
elif dis == 1:
good_pred_count += 1
return good_pred_count, failed_pred_count
def view_predict_hmap(predout, show_raw=False):
from data_process import draw_labelmap
gtmap = predout[-1]
gtmap = gtmap[0, :, :, :]
if show_raw:
mimage = gtmap
else:
mimage = np.zeros(shape=gtmap.shape, dtype=np.float)
kplst = post_process_heatmap(gtmap)
for i, kpoint in enumerate(kplst):
mimage[:, :, i] = draw_labelmap(mimage[:, :, i], kpoint, sigma=2)
sumimage = np.zeros(shape=(64, 64))
for i in range(gtmap.shape[-1]):
sumimage += mimage[:, :, i]
scipy.misc.imshow(sumimage)
def run_eval(model_json, model_weights, epoch):
model = load_model(model_json, model_weights)
model.compile(optimizer=RMSprop(lr=5e-4),
loss=mean_squared_error,
metrics=["accuracy"])
# dataset_path = '/home/tomas_bordac/nyu_croped'
# dataset_path = '..\\..\\data\\nyu_croped'
# dataset_path = os.path.join('D:\\', 'nyu_croped')
dataset_path = config_reader.load_path()
valdata = NYUHandDataGen('joint_data.mat',
dataset_path,
inres=(256, 256),
outres=(64, 64),
is_train=False,
is_testtrain=False)
total_suc, total_fail = 0, 0
threshold = 1
count = 0
batch_size = 8
for _img, _gthmap, _meta in valdata.generator(batch_size,
2,
sigma=3,
is_shuffle=False,
with_meta=True):
count += batch_size
if count > valdata.get_dataset_size():
break
out = model.predict(_img)
pred_map_batch = out[-1]
if show_outputs:
for i in range(batch_size):
orig_image = cv2.resize(_img[i],
dsize=(480, 480),
interpolation=cv2.INTER_CUBIC)
kpanno = _meta[i]['tpts']
pred_heatmaps = pred_map_batch[i]
pred_kps = post_process_heatmap(pred_heatmaps)
pred_kps = np.array(pred_kps)
for j in range(kpanno.shape[0]):
x = kpanno[j, 0]
y = kpanno[j, 1]
orig_image = cv2.circle(orig_image, (int(x), int(y)), 5,
(0, 0, 255), 2)
for j in range(pred_kps.shape[0]):
x = pred_kps[j, 0] * 4
y = pred_kps[j, 1] * 4
_img[i] = cv2.circle(_img[i], (int(x), int(y)), 5,
(0, 0, 255), 2)
cv2.imshow('orig with heatmaps', orig_image)
cv2.imshow('gt heatmap', np.sum(_gthmap[-1][i], axis=-1))
cv2.imshow('pred with heatmaps', _img[i])
cv2.imshow(
'pred heatmaps',
cv2.resize(np.sum(pred_heatmaps, axis=-1),
dsize=(256, 256),
interpolation=cv2.INTER_CUBIC))
cv2.imshow(
'pred heatmap',
cv2.resize(pred_heatmaps[0],
dsize=(256, 256),
interpolation=cv2.INTER_CUBIC))
cv2.waitKey(0)
suc, bad = cal_heatmap_acc(out[-1], _meta, threshold)
total_suc += suc
total_fail += bad
print('success: {}'.format(suc))
print('bad: {}'.format(bad))
if bad > 0:
input()
acc = total_suc * 1.0 / (total_fail + total_suc)
print('Eval Accuray ', acc, '@ Epoch ', epoch)
