def visualize_img(self, img, gt_kp, vert, pred_kp, cam, renderer):
"""
Overlays gt_kp and pred_kp on img.
Draws vert with text.
Renderer is an instance of SMPLRenderer.
"""
gt_vis = gt_kp[:, 2].astype(bool)
loss = np.sum((gt_kp[gt_vis, :2] - pred_kp[gt_vis])**2)
debug_text = {"sc": cam[0], "tx": cam[1], "ty": cam[2], "kpl": loss}
# Fix a flength so i can render this with persp correct scale
f = 5.
tz = f / cam[0]
cam_for_render = 0.5 * self.img_size * np.array([f, 1, 1])
cam_t = np.array([cam[1], cam[2], tz])
# Undo pre-processing.
input_img = (img + 1) * 0.5
rend_img = renderer(vert + cam_t, cam_for_render, img=input_img)
rend_img = vis_util.draw_text(rend_img, debug_text)
# Draw skeleton
gt_joint = ((gt_kp[:, :2] + 1) * 0.5) * self.img_size
pred_joint = ((pred_kp + 1) * 0.5) * self.img_size
img_with_gt = vis_util.draw_skeleton(input_img,
gt_joint,
draw_edges=False,
vis=gt_vis)
skel_img = vis_util.draw_skeleton(img_with_gt, pred_joint)
combined = np.hstack([skel_img, rend_img / 255.])
# import matplotlib.pyplot as plt
# plt.ion()
# plt.imshow(skel_img)
# import ipdb; ipdb.set_trace()
return combined
def visualize_3d2(img_t, proc_param_t, joints_t, verts_t, cam_t, joints3d_t,
img_q, proc_param_q, joints_q, verts_q, cam_q, joints3d_q):
"""
Renders the result in original image coordinate frame.
"""
import matplotlib.pyplot as plt
fig = plt.figure()
## Pose 1
cam_for_render_t, vert_shifted_t, joints_orig_t = vis_util.get_original(
proc_param_t, verts_t, cam_t, joints_t, img_size=img_t.shape[:2])
# Render results
ax_3d_t = fig.add_subplot(221, projection='3d')
ax_3d_t = vis_util.draw_skeleton_3d(joints3d_t, ax_3d_t)
ax_img_t = fig.add_subplot(222)
skel_img_t = vis_util.draw_skeleton(img_t, joints_orig_t)
ax_img_t.imshow(skel_img_t)
## Pose 2
cam_for_render_q, vert_shifted_q, joints_orig_q = vis_util.get_original(
proc_param_q, verts_q, cam_q, joints_q, img_size=img_q.shape[:2])
# Render results
ax_3d_q = fig.add_subplot(223, projection='3d')
ax_3d_q = vis_util.draw_skeleton_3d(joints3d_q, ax_3d_q)
ax_img_q = fig.add_subplot(224)
skel_img_q = vis_util.draw_skeleton(img_q, joints_orig_q)
ax_img_q.imshow(skel_img_q)
plt.draw()
plt.show()
def visualize_and_save(img, proc_param, joints, verts, cam, save_path,
frame_num):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=img,
do_alpha=True)
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(vert_shifted,
60,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(vert_shifted,
-60,
cam=cam_for_render,
img_size=img.shape[:2])
combined_img = np.concatenate(
(rend_img_overlay, rend_img_vp1, rend_img_vp2), axis=0)
cv2.imshow('frame', combined_img)
if save_path is not None:
cv2.imwrite(save_path + str(frame_num) + "hmr_result.png",
combined_img)
def visualize(img, proc_param, joints_crop, verts_crop, cam_crop):
# render using opendr
cam_render, verts_render, joints_render = vis_util.get_original(
proc_param, verts_crop, cam_crop, joints_crop, img_size=img.shape[:2])
skel_img = vis_util.draw_skeleton(img, joints_render)
rend_img_overlay = renderer(verts_render,
cam=cam_render,
img=img,
do_alpha=True)
rend_img = renderer(verts_render, cam=cam_render, img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(verts_render,
60,
cam=cam_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(verts_render,
-60,
cam=cam_render,
img_size=img.shape[:2])
# draw verts projected on original image
verts2d = project_3d_to_original2d_v2(cam_crop, verts_crop, proc_param)
verts_z = verts_crop[:, 2]
verts2d_img = draw_2d_verts(np.zeros(img.shape, dtype=np.uint8), verts2d,
verts_z)
verts2d_img_overlay = draw_2d_verts(img, verts2d, verts_z)
verts2d_rend_overlay = draw_2d_verts(rend_img, verts2d, verts_z)
row1 = np.hstack([img, skel_img, rend_img_overlay[..., :3]])
row2 = np.hstack([rend_img, rend_img_vp1[..., :3], rend_img_vp2[..., :3]])
row3 = np.hstack([verts2d_img, verts2d_img_overlay, verts2d_rend_overlay])
vis = np.vstack([row1, row2, row3])
return vis
def visualize(img, proc_param, joints, verts, cam):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=img,
do_alpha=True)
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(vert_shifted,
60,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(vert_shifted,
-60,
cam=cam_for_render,
img_size=img.shape[:2])
'''
def visualize_3d(img, proc_param, joints, verts, cam, joints3d):
"""
Renders the result in original image coordinate frame.
"""
import matplotlib.pyplot as plt
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
fig = plt.figure()
ax = fig.add_subplot(121, projection='3d')
print("Joints shape 3d:" + str(joints3d.shape))
ax = vis_util.draw_skeleton_3d(joints3d, ax)
#plt = vis_util.draw_skeleton_3d(img, joints_orig, plt)
ax1 = fig.add_subplot(122)
skel_img = vis_util.draw_skeleton(img, joints_orig)
ax1.imshow(skel_img)
# plt.ion()
plt.title('diff vp')
plt.axis('off')
plt.draw()
plt.show()
def visualize(img, proc_param, joints, verts, cam, image_name=None):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
# rend_img_overlay = renderer(
# vert_shifted, cam=cam_for_render, img=img, do_alpha=True)
# rend_img = renderer(
# vert_shifted, cam=cam_for_render, img_size=img.shape[:2])
# rend_img_vp1 = renderer.rotated(
# vert_shifted, 60, cam=cam_for_render, img_size=img.shape[:2])
# rend_img_vp2 = renderer.rotated(
# vert_shifted, -60, cam=cam_for_render, img_size=img.shape[:2])
cv2.namedWindow('input' + image_name, cv2.WINDOW_NORMAL)
cv2.namedWindow('joint projection' + image_name, cv2.WINDOW_NORMAL)
cv2.imshow('input' + image_name, img)
cv2.imshow('joint projection' + image_name, skel_img)
# cv2.imshow('3D Mesh overlay',rend_img_overlay)
# cv2.imshow('3D mesh',rend_img)
# cv2.imshow('diff vp',rend_img_vp1)
# cv2.imshow('diff vp 2',rend_img_vp2)
cv2.waitKey(25)
"""
def visualize(img, proc_param, joints, verts, cam):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=img,
do_alpha=True)
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(vert_shifted,
60,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(vert_shifted,
-60,
cam=cam_for_render,
img_size=img.shape[:2])
import matplotlib.pyplot as plt
# plt.ion()
plt.figure(1)
plt.clf()
plt.imshow(rend_img_overlay)
plt.title('3D Mesh overlay')
plt.axis('off')
plt.draw()
plt.savefig('./HMR_moi_7.png')
plt.show()
def visualize(img, proc_param, joints, verts, cam):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=img,
do_alpha=True)
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(vert_shifted,
60,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(vert_shifted,
-60,
cam=cam_for_render,
img_size=img.shape[:2])
# plt.ion()
# plt.figure(1)
# plt.clf()
# plt.subplot(231)
# plt.imshow(img)
# plt.title('input')
# plt.axis('off')
# plt.subplot(232)
# plt.imshow(skel_img)
out.write(skel_img)
def visualize(img_path, img, proc_param, joints, verts, cam):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=img,
do_alpha=True)
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(vert_shifted,
60,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(vert_shifted,
-60,
cam=cam_for_render,
img_size=img.shape[:2])
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
# plt.ion()
plt.figure(1)
plt.clf()
plt.subplot(231)
plt.imshow(img)
plt.title('input')
plt.axis('off')
plt.subplot(232)
plt.imshow(skel_img)
plt.title('joint projection')
plt.axis('off')
plt.subplot(233)
plt.imshow(rend_img_overlay)
plt.title('3D Mesh overlay')
plt.axis('off')
plt.subplot(234)
plt.imshow(rend_img)
plt.title('3D mesh')
plt.axis('off')
plt.subplot(235)
plt.imshow(rend_img_vp1)
plt.title('diff vp')
plt.axis('off')
plt.subplot(236)
plt.imshow(rend_img_vp2)
plt.title('diff vp')
plt.axis('off')
plt.draw()
plt.savefig("hmr/output/images/" +
os.path.splitext(os.path.basename(img_path))[0] + ".png")
def save(img, proc_param, joints, verts, cam, i):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=img,
do_alpha=True)
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(vert_shifted,
60,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(vert_shifted,
-60,
cam=cam_for_render,
img_size=img.shape[:2])
import matplotlib.pyplot as plt
# plt.ion()
plt.figure(i)
plt.clf()
plt.subplot(231)
plt.imshow(img)
plt.title('input')
plt.axis('off')
plt.subplot(232)
plt.imshow(skel_img)
plt.title('joint projection')
plt.axis('off')
plt.subplot(233)
plt.imshow(rend_img_overlay)
plt.title('3D Mesh overlay')
plt.axis('off')
plt.subplot(234)
plt.imshow(rend_img)
plt.title('3D mesh')
plt.axis('off')
plt.subplot(235)
plt.imshow(rend_img_vp1)
plt.title('diff vp')
plt.axis('off')
plt.subplot(236)
plt.imshow(rend_img_vp2)
plt.title('diff vp')
plt.axis('off')
plt.draw()
#plt.show()
name = str(i) + ".png"
print(name)
plt.savefig(name)
def visualize(img, proc_param, renderer, joints, verts, cam):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=img,
do_alpha=True)
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(vert_shifted,
60,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(vert_shifted,
-60,
cam=cam_for_render,
img_size=img.shape[:2])
# plt.ion()
fig = plt.figure(1)
plt.clf()
plt.subplot(231)
plt.imshow(img)
plt.title('input')
plt.axis('off')
plt.subplot(232)
plt.imshow(skel_img)
plt.title('joint projection')
plt.axis('off')
plt.subplot(233)
plt.imshow(rend_img_overlay)
plt.title('3D Mesh overlay')
plt.axis('off')
plt.subplot(234)
plt.imshow(rend_img)
plt.title('3D mesh')
plt.axis('off')
plt.subplot(235)
plt.imshow(rend_img_vp1)
plt.title('diff vp')
plt.axis('off')
plt.subplot(236)
plt.imshow(rend_img_vp2)
plt.title('diff vp')
plt.axis('off')
plt.draw()
plt.show()
# import ipdb
# ipdb.set_trace()
return fig
def visualize_joints2d_3kinds(img, joints1, joints2, joints3, save_fig_result):
"""
Renders the result in original image coordinate frame.
"""
# Render results
skel_img1 = vis_util.draw_skeleton(img, joints1)
skel_img2 = vis_util.draw_skeleton(img, joints2)
skel_img3 = vis_util.draw_skeleton(img, joints3)
import matplotlib.pyplot as plt
# plt.ion()
plt.figure(1)
plt.clf()
plt.subplot(311)
plt.imshow(skel_img1)
plt.title('joints2d_gt')
plt.axis('off')
plt.subplot(312)
plt.title('joints 3d smpl ext/intric projection')
plt.imshow(skel_img2)
plt.axis('off')
plt.subplot(313)
plt.imshow(skel_img3)
plt.title('joints 3d tf smpl ext/intric projection')
plt.axis('off')
plt.draw()
"""
> see https://hub.docker.com/r/dawars/hmr/
Matplotlib cannot open a window in docker (by default),
therefore it needs to replaced by saving the figures
instead: In the demo.py change plt.show() to plt.savefig("figure.png")
"""
# added by CCJ;
dockerEnv = True
if not dockerEnv:
plt.show()
else:
plt.savefig(save_fig_result)
print("saved %s ..." % save_fig_result)
def visualize(img, proc_param, joints, verts, cam, img_path):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
centered_cam = (0.9, 0, 0) # used to see fully-visible views of person
cam_for_render2, vert_shifted2, joints_orig2 = vis_util.get_original(
proc_param, verts, centered_cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints)
f = 5.
tz = f / cam[0]
cam_for_render = 0.5 * 224 * np.array([f, 1, 1])
cam_t = np.array([cam[1], cam[2], tz])
rend_img_overlay = renderer(verts + cam_t, cam=cam_for_render, img=img)
#rend_img_overlay = renderer(
# vert_shifted, cam=cam_for_render, img=img, do_alpha=True)
rend_img = renderer(verts + cam_t,
cam=cam_for_render,
img_size=img.shape[:2])
cam_t2 = np.array([cam[1], cam[2], tz * 2])
rend_img_vp1 = renderer.rotated(verts + cam_t2,
60,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(verts + cam_t2,
-60,
cam=cam_for_render,
img_size=img.shape[:2])
import matplotlib
matplotlib.use('agg')
import matplotlib.pyplot as plt
# plt.ion()
plt.figure(1)
plt.clf()
plt.subplot(131)
plt.imshow(img)
plt.title('input')
plt.axis('off')
plt.subplot(132)
plt.imshow(rend_img_overlay)
plt.title('3D Mesh overlay')
plt.axis('off')
plt.subplot(133)
plt.imshow(rend_img)
plt.title('3D mesh')
plt.axis('off')
plt.draw()
plt.show()
plt.savefig(img_path[:-4] + '_preds' + '.png')
def visualize_3d3(img_t, proc_param_t, joints_t, verts_t, cam_t, joints3d_t,
img_q, proc_param_q, joints_q, verts_q, cam_q, joints3d_q):
"""
Renders the result in original image coordinate frame.
"""
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
gs = gridspec.GridSpec(2, 2)
fig = plt.figure()
ax_3d = fig.add_subplot(gs[:, 0], projection='3d')
cam_for_render_t, vert_shifted_t, joints_orig_t = vis_util.get_original(
proc_param_t, verts_t, cam_t, joints_t, img_size=img_t.shape[:2])
# Render results
ax_3d = vis_util.draw_skeleton_3d(joints3d_t, ax_3d, 'b')
ax_3d = vis_util.draw_skeleton_3d(joints3d_q, ax_3d, 'g')
ax_3d = vis_util.draw_displacement(joints3d_t, joints3d_q, ax_3d)
print("Cam param :" + str(cam_t))
print("Cam shape :" + str(cam_t.shape))
ax_3d = vis_util.draw_arrow(cam_t, [0, 0, 0], ax_3d)
## Pose 1
cam_for_render_t, vert_shifted_t, joints_orig_t = vis_util.get_original(
proc_param_t, verts_t, cam_t, joints_t, img_size=img_t.shape[:2])
# Render results
ax_img_t = fig.add_subplot(gs[0, 1])
skel_img_t = vis_util.draw_skeleton(img_t, joints_orig_t)
ax_img_t.imshow(skel_img_t)
## Pose 2
cam_for_render_q, vert_shifted_q, joints_orig_q = vis_util.get_original(
proc_param_q, verts_q, cam_q, joints_q, img_size=img_q.shape[:2])
# Render results
ax_img_q = fig.add_subplot(gs[1, 1])
skel_img_q = vis_util.draw_skeleton(img_q, joints_orig_q)
ax_img_q.imshow(skel_img_q)
plt.draw()
plt.show()
def visualize(img, proc_param, joints, verts, cam):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
#visualize(img, proc_param, joints[0], verts[0], cams[0])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(
#vert_shifted, cam=None, img=img, do_alpha=True)
vert_shifted, cam=cam_for_render, img=img, do_alpha=True)
rend_img = renderer(
vert_shifted, cam=cam_for_render, img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(
vert_shifted, 60, cam=cam_for_render, img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(
vert_shifted, -60, cam=cam_for_render, img_size=img.shape[:2])
import matplotlib
matplotlib.use('agg')
import matplotlib.pyplot as plt
# plt.ion()
fig = plt.figure()
plt.figure(1)
plt.clf()
plt.subplot(231)
plt.imshow(img)
plt.title('input')
plt.axis('off')
plt.subplot(232)
plt.imshow(skel_img)
plt.title('joint projection')
plt.axis('off')
plt.subplot(233)
plt.imshow(rend_img_overlay)
plt.title('3D Mesh overlay')
plt.axis('off')
plt.subplot(234)
plt.imshow(rend_img)
result = Image.fromarray(rend_img)
result.save('mesh.jpg')
plt.title('3D mesh')
plt.axis('off')
plt.subplot(235)
plt.imshow(rend_img_vp1)
plt.title('diff vp')
plt.axis('off')
plt.subplot(236)
plt.imshow(rend_img_vp2)
plt.title('diff vp')
plt.axis('off')
plt.draw()
fig.savefig('demo.jpg')
def visualize(img_path, img, proc_param, joints, verts, cam, folder_name):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(
vert_shifted, cam=cam_for_render, img=img, do_alpha=True)
rend_img = renderer(
vert_shifted, cam=cam_for_render, img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(
vert_shifted, 60, cam=cam_for_render, img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(
vert_shifted, -60, cam=cam_for_render, img_size=img.shape[:2])
import matplotlib.pyplot as plt
# plt.ion()
# plt.figure(1)
# plt.clf()
# plt.subplot(231)
# plt.imshow(img)
# plt.title('input')
# plt.axis('off')
# plt.subplot(232)
# plt.imshow(skel_img)
# plt.title('joint projection')
# plt.axis('off')
# plt.subplot(233)
# plt.imshow(rend_img_overlay)
# plt.title('3D Mesh overlay')
# plt.axis('off')
# plt.subplot(234)
# plt.imshow(rend_img)
# plt.title('3D mesh')
# plt.axis('off')
# plt.subplot(235)
# plt.imshow(rend_img_vp1)
# plt.title('diff vp')
# plt.axis('off')
# plt.subplot(236)
# plt.imshow(rend_img_vp2)
# plt.title('diff vp')
# plt.axis('off')
# plt.draw()
# plt.show()
# import ipdb
# ipdb.set_trace()
#plt.imshow(rend_img_overlay)
#plt.show()
rend_img_overlay = cv2.cvtColor(rend_img_overlay, cv2.COLOR_BGR2RGB)
cv2.imwrite("/home/ankur/GUI_project/frames/FRAMES_HMR/"+ folder_name + '/' + img_path.split('/')[-1][:-4]+".png",rend_img_overlay)
def visualize(img, proc_param, joints, verts, cam, image_path):
"""
Renders the result in original image coordinate frame.
Saves result in same directory as image_path.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
print(cam_for_render)
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(
vert_shifted, cam=cam_for_render, img=img, do_alpha=True)
rend_img = renderer(
vert_shifted, cam=cam_for_render, img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(
vert_shifted, 60, cam=cam_for_render, img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(
vert_shifted, -60, cam=cam_for_render, img_size=img.shape[:2])
import matplotlib.pyplot as plt
# plt.ion()
plt.figure(1)
plt.clf()
plt.subplot(231)
plt.imshow(img)
plt.title('input')
plt.axis('off')
plt.subplot(232)
plt.imshow(skel_img)
plt.title('joint projection')
plt.axis('off')
plt.subplot(233)
plt.imshow(rend_img_overlay)
plt.title('3D Mesh overlay')
plt.axis('off')
plt.subplot(234)
plt.imshow(rend_img)
plt.title('3D mesh')
plt.axis('off')
plt.subplot(235)
plt.imshow(rend_img_vp1)
plt.title('diff vp')
plt.axis('off')
plt.subplot(236)
plt.imshow(rend_img_vp2)
plt.title('diff vp')
plt.axis('off')
plt.draw()
# plt.show()
plt.savefig(image_path + "hmr_result.png", format='png')
# import ipdb
# ipdb.set_trace()
plt.imsave(image_path + "hmr_overlay.png", rend_img_overlay)
def visualize(img_path, img, proc_param, joints, verts, cam, output):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
# TODO: add alpha to avatar
rend_img_overlay = renderer(
vert_shifted, cam=cam_for_render, img=skel_img, do_alpha=True)
# rend_img_overlay = vis_util.draw_skeleton(rend_img_overlay, joints_orig)
rend_img = renderer(
vert_shifted, cam=cam_for_render, img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(
vert_shifted, 60, cam=cam_for_render, img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(
vert_shifted, -60, cam=cam_for_render, img_size=img.shape[:2])
import matplotlib.pyplot as plt
# plt.ion()
plt.figure(1, figsize=(10, 10))
plt.clf()
plt.subplot(231)
plt.imshow(img)
plt.title('input')
plt.axis('off')
plt.subplot(232)
plt.imshow(skel_img)
plt.title('joint projection')
plt.axis('off')
plt.subplot(233)
plt.imshow(rend_img_overlay)
plt.title('3D Mesh overlay')
plt.axis('off')
plt.subplot(234)
plt.imshow(rend_img)
plt.title('3D mesh')
plt.axis('off')
plt.subplot(235)
plt.imshow(rend_img_vp1)
plt.title('diff vp')
plt.axis('off')
plt.subplot(236)
plt.imshow(rend_img_vp2)
plt.title('diff vp')
plt.axis('off')
plt.draw()
print('saving to %s' % output)
plt.savefig(os.path.join(output, os.path.splitext(os.path.basename(img_path))[0] + ".png"))
io.imsave(os.path.join(output, os.path.splitext(os.path.basename(img_path))[0] + "_big.png"), rend_img_overlay) # rend_img[:,:,:3])#
def visualize(img, proc_param, joints, verts, cam, filename):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=img,
do_alpha=True)
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(vert_shifted,
60,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(vert_shifted,
-60,
cam=cam_for_render,
img_size=img.shape[:2])
import matplotlib.pyplot as plt
plt.clf()
plt.imshow(img)
plt.title('input')
plt.axis('off')
plt.savefig("exp/figure/" + filename + "-a.png",
format='png',
transparent=True,
dpi=800)
plt.clf()
plt.imshow(skel_img)
plt.title('joint projection')
plt.axis('off')
plt.savefig("exp/figure/" + filename + "-b.png",
format='png',
transparent=True,
dpi=800)
plt.clf()
plt.imshow(rend_img_overlay)
plt.title('3D Mesh overlay')
plt.axis('off')
plt.savefig("exp/figure/" + filename + "-c.png",
format='png',
transparent=True,
dpi=800)
def visualize(img, proc_param, joints, verts, cam, dst_path):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(
vert_shifted, cam=cam_for_render, img=img, do_alpha=True)
rend_img = renderer(
vert_shifted, cam=cam_for_render, img_size=img.shape[:2])
result = Image.fromarray(rend_img).convert('L')
result.save(dst_path)
def visualize(img_path, img, proc_param, joints, verts, cam):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=img,
do_alpha=True,
img_size=img.shape[:2])
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(vert_shifted,
60,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(vert_shifted,
-60,
cam=cam_for_render,
img_size=img.shape[:2])
import matplotlib.pyplot as plt
# plt.ion()
height, width, depth = img.shape
dpi = 100
figsize = width / float(dpi), height / float(dpi)
plt.figure(1, figsize=figsize)
plt.clf()
plt.subplot(111)
plt.imshow(rend_img_overlay)
plt.axis('off')
plt.draw()
plt.savefig("fixedhmr/output/images/" +
os.path.splitext(os.path.basename(img_path))[0] + ".png")
def visualize_all(num_persons, img, proc_params, joints, verts, cam):
"""
Renders the result in original image coordinate frame.
"""
skel_img = np.copy(img)
rend_img_overlay = np.copy(img)
rend_img = np.zeros(shape=img.shape)
# rend_img_vp1 = np.zeros(shape=img.shape)
# rend_img_vp2 = np.zeros(shape=img.shape)
for idx in range(num_persons):
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_params[idx],
verts[idx],
cam[idx],
joints[idx],
img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(skel_img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=rend_img_overlay,
do_alpha=True,
color_id=idx)
rend_img_overlay = rend_img_overlay[:, :, :3]
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img=rend_img,
img_size=img.shape[:2],
color_id=idx)
# rend_img_vp1 = renderer.rotated(
# vert_shifted, 60, cam=cam_for_render, img=rend_img_vp1, img_size=img.shape[:2])
# rend_img_vp2 = renderer.rotated(
# vert_shifted, -60, cam=cam_for_render, img=rend_img_vp2, img_size=img.shape[:2])
import matplotlib.pyplot as plt
# plt.ion()
plt.figure(1)
plt.clf()
plt.subplot(221)
plt.imshow(img)
plt.title('Image')
plt.axis('off')
plt.subplot(222)
plt.imshow(skel_img)
plt.title('Joints 2D Projection')
plt.axis('off')
plt.subplot(223)
plt.imshow(rend_img_overlay)
plt.title('3D Mesh Overlay')
plt.axis('off')
plt.subplot(224)
plt.imshow(rend_img)
plt.title('3D Mesh')
plt.axis('off')
# plt.subplot(235)
# plt.imshow(rend_img_vp1)
# plt.title('diff vp')
# plt.axis('off')
# plt.subplot(236)
# plt.imshow(rend_img_vp2)
# plt.title('diff vp')
# plt.axis('off')
plt.draw()
plt.show()
def visualize(img, proc_param, joints, verts, cam):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=img,
do_alpha=True)
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(vert_shifted,
60,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(vert_shifted,
-60,
cam=cam_for_render,
img_size=img.shape[:2])
import matplotlib.pyplot as plt
# plt.ion()
plt.figure(1)
plt.clf()
plt.subplot(231)
plt.imshow(img)
plt.title('input')
plt.axis('off')
plt.subplot(232)
plt.imshow(skel_img)
plt.title('joint projection')
plt.axis('off')
plt.subplot(233)
plt.imshow(rend_img_overlay)
plt.title('3D Mesh overlay')
plt.axis('off')
plt.subplot(234)
plt.imshow(rend_img)
plt.title('3D mesh')
plt.axis('off')
plt.subplot(235)
plt.imshow(rend_img_vp1)
plt.title('diff vp')
plt.axis('off')
plt.subplot(236)
plt.imshow(rend_img_vp2)
plt.title('diff vp')
plt.axis('off')
plt.draw()
"""
> see https://hub.docker.com/r/dawars/hmr/
Matplotlib cannot open a window in docker (by default),
therefore it needs to replaced by saving the figures
instead: In the demo.py change plt.show() to plt.savefig("figure.png")
"""
# added by CCJ;
dockerEnv = True
if not dockerEnv:
plt.show()
else:
plt.savefig("results/figure.png")
print("saved results/figure.png ...")
# import ipdb
# ipdb.set_trace()
return cam_for_render
def main(config):
gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
try:
# Currently, memory growth needs to be the same across GPUs
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
logical_gpus = tf.config.experimental.list_logical_devices('GPU')
print(len(gpus), "Physical GPUs,", len(logical_gpus), "Logical GPUs")
except RuntimeError as e:
# Memory growth must be set before GPUs have been initialized
print(e)
renderer = vis_util.SMPLRenderer(
img_size=config.img_size,
face_path=config.smpl_face_path)
config.checkpoint_dir = "training_checkpoints_125_epochs_lspe"
predictor = Predictor(config)
cv2.namedWindow("preview", cv2.WINDOW_NORMAL)
cv2.setWindowProperty("preview", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)
vc = cv2.VideoCapture(0)
if vc.isOpened(): # try to get the first frame
rval, frame = vc.read()
else:
rval = False
draw_skel = False
draw_mesh = True
rotate_img = False
show_both = False
while rval:
frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
input_img, proc_param, img = preprocess_image(frame, config)
verts, cam, joints = predictor.do_prediction(input_img)
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, np.squeeze(verts), np.squeeze(cam), np.squeeze(joints)[:,:2], img_size=frame.shape[:2])
if tf.math.is_nan(joints_orig).numpy().any():
print("nothing found")
rend_img = frame
else:
if draw_skel:
rend_img = vis_util.draw_skeleton(frame, joints_orig)
if draw_mesh:
if rotate_img:
rend_img = renderer.rotated(vert_shifted, 60, cam=cam_for_render, img_size=frame.shape[:2])
else:
rend_img = renderer(vert_shifted, cam_for_render, frame, True)
if show_both:
img2 = renderer.rotated(vert_shifted, 60, cam=cam_for_render, img_size=frame.shape[:2])
rend_img = np.concatenate((rend_img, img2), axis=1)
cv2.imshow("preview", rend_img)
for i in range(5):
rval, frame = vc.read()
key = cv2.waitKey(20)
if key == 27: # exit on ESC
break
if key == ord('s'):
draw_skel = True
draw_mesh = False
rotate_img = False
show_both = False
if key == ord('m'):
draw_skel = False
draw_mesh = True
rotate_img = False
show_both = False
if key == ord('r'):
draw_skel = False
draw_mesh = True
rotate_img = True
show_both = False
if key == ord('b'):
draw_skel = False
draw_mesh = True
rotate_img = False
show_both = True
cv2.destroyWindow("preview")
def render_bb_joints_verts(bb_img,
proc_param,
joints,
verts,
cam,
image_path,
person_num,
visualise=False,
save=False,
outfile=None):
"""
Renders the result in original image coordinate frame FOR EACH BOUNDING BOX.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=bb_img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(bb_img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=bb_img,
do_alpha=True)
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img_size=bb_img.shape[:2])
rend_img_vp1 = renderer.rotated(vert_shifted,
60,
cam=cam_for_render,
img_size=bb_img.shape[:2])
rend_img_vp2 = renderer.rotated(vert_shifted,
-60,
cam=cam_for_render,
img_size=bb_img.shape[:2])
if visualise or save:
import matplotlib.pyplot as plt
# plt.ion()
plt.figure(1)
plt.clf()
plt.subplot(231)
plt.imshow(bb_img)
plt.title('input')
plt.axis('off')
plt.subplot(232)
plt.imshow(skel_img)
plt.title('joint projection')
plt.axis('off')
plt.subplot(233)
plt.imshow(rend_img_overlay)
plt.title('3D Mesh overlay')
plt.axis('off')
plt.subplot(234)
plt.imshow(rend_img)
plt.title('3D mesh')
plt.axis('off')
plt.subplot(235)
plt.imshow(rend_img_vp1)
plt.title('diff vp')
plt.axis('off')
plt.subplot(236)
plt.imshow(rend_img_vp2)
plt.title('diff vp')
plt.axis('off')
plt.draw()
if visualise:
plt.show()
if save:
if outfile is None:
plt.savefig(splitext(image_path)[0] + "_hmr_result_person" +
str(person_num) + ".png",
format='png')
else:
plt.savefig(outfile + "_hmr_result_person" + str(person_num) +
".png",
format='png')
return skel_img, rend_img_overlay
def visualize(img, proc_param, joints, verts, cam):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
print('original predicted camera: ', cam)
print('camera for renderer: ', cam_for_render)
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=img,
do_alpha=True)
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(vert_shifted,
60,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(vert_shifted,
-60,
cam=cam_for_render,
img_size=img.shape[:2])
import matplotlib.pyplot as plt
## plt.ion()
plt.figure(1)
# plt.clf()
# plt.subplot(231)
# plt.imshow(img)
# plt.title('input')
# plt.axis('off')
# plt.subplot(232)
# plt.imshow(skel_img)
# plt.title('joint projection')
# plt.axis('off')
# plt.subplot(233)
# plt.imshow(rend_img_overlay)
# plt.title('3D Mesh overlay')
# plt.axis('off')
# plt.subplot(234)
plt.imshow(rend_img)
# plt.title('3D mesh')
plt.axis('off')
# plt.subplot(235)
# plt.imshow(rend_img_vp1)
# plt.title('diff vp')
# plt.axis('off')
# plt.subplot(236)
# plt.imshow(rend_img_vp2)
# plt.title('diff vp')
# plt.axis('off')
plt.savefig('ronaldo/hmr_output.jpg')
plt.draw()
def scale_and_crop_with_gt(
image,
scale,
center, # NOTE: image center in (x,y), i.e., [width_dim, height_dim]
img_size, # e.g., == 224;
joints2d_gt, # in shape [2, 14]
cam_gt # in shape [3,]
):
image_scaled, scale_factors = resize_img(image, scale)
print("scale = {}, image_scaled shape : {}".format(scale,
image_scaled.shape))
# Swap so it's [x, y]
scale_factors = [scale_factors[1], scale_factors[0]]
center_scaled = np.round(center * scale_factors).astype(np.int)
margin = int(img_size / 2)
image_pad = np.pad(image_scaled, ((margin, ), (margin, ), (0, )),
mode='edge')
center_pad = center_scaled + margin
# figure out starting point
start_pt = center_pad - margin
end_pt = center_pad + margin
# crop:
crop = image_pad[start_pt[1]:end_pt[1], start_pt[0]:end_pt[0], :]
# Update 2d joints;
joints2d_gt_scaled = np.copy(joints2d_gt)
print("[????] joints2d_gt shape = ", joints2d_gt.shape)
assert (joints2d_gt.shape[1] == 14)
joints2d_gt_scaled[0, :] *= scale_factors[0] # x
joints2d_gt_scaled[1, :] *= scale_factors[1] # y
joints2d_gt_scaled[0, :] -= (start_pt[0] - margin) # x;
joints2d_gt_scaled[1, :] -= (start_pt[1] - margin) # y;
# Update principal point:
cam_gt_scaled = np.copy(cam_gt)
cam_gt_scaled[0] *= scale
cam_gt_scaled[1] *= scale_factors[0] # tx
cam_gt_scaled[2] *= scale_factors[1] # ty
cam_gt_scaled[1] -= (start_pt[0] - margin) # tx
cam_gt_scaled[2] -= (start_pt[1] - margin) # ty
#print ("cam_gt type = {}, cam_gt = {}, cam_gt_scaled = {}".format(
# type(cam_gt[0]), cam_gt, cam_gt_scaled))
print("crop shape : ", crop.shape)
proc_param = {
'scale_factors': scale_factors, # added by CCJ;
'scale': scale,
'start_pt': start_pt,
'end_pt': end_pt,
'img_size': img_size
}
import matplotlib.pyplot as plt
plt.figure(1)
plt.clf()
plt.subplot(221)
plt.imshow(crop[:, :, :3].astype(np.uint8))
#print ("[crop image ***] = {}".format(crop[110:115, 110:115,:3]))
#print ("[crop depth ***] = {}".format(crop[110:115, 110:115, 3]))
plt.title('scaled input')
plt.axis('off')
plt.subplot(222)
dep = crop[:, :, 3]
dep = surreal_util.normalizeDepth(dep, isNormalized=True) * 255
plt.imshow(dep.astype(np.uint8))
plt.title('scaled depth')
plt.axis('off')
plt.subplot(223)
skel_img = renderer.draw_skeleton(crop[:, :, :3].astype(np.uint8),
joints2d_gt_scaled)
plt.imshow(skel_img)
plt.title('scaled')
plt.axis('off')
plt.subplot(224)
plt.imshow(
renderer.draw_skeleton(image[:, :, :3].astype(np.uint8), joints2d_gt))
plt.title('original')
plt.axis('off')
plt.draw()
plt.savefig("/home/hmr/results/surreal_debug/scale_img_joints2d_gt.png")
return crop, proc_param, joints2d_gt_scaled, cam_gt_scaled
def visualize(img, proc_param, joints, verts, cam):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=img,
do_alpha=True)
##############
deg = 180
around = cv2.Rodrigues(np.array([math.radians(deg), 0, 0]))[0]
center = vert_shifted.mean(axis=0)
new_v = np.dot((vert_shifted - center), around) + center
faces = np.load(smpl_face_path)
outmesh_path = os.path.join('results', 'smpl_tf.obj')
with open(outmesh_path, 'w') as fp:
for v in new_v:
fp.write('v %f %f %f\n' % (v[0], v[1], v[2]))
for f in faces + 1:
fp.write('f %d %d %d\n' % (f[0], f[1], f[2]))
##############
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(vert_shifted,
60,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(vert_shifted,
-60,
cam=cam_for_render,
img_size=img.shape[:2])
import matplotlib.pyplot as plt
# plt.ion()
plt.figure(1)
plt.clf()
plt.subplot(231)
plt.imshow(img)
plt.title('input')
plt.axis('off')
plt.subplot(232)
plt.imshow(skel_img)
plt.title('joint projection')
plt.axis('off')
plt.subplot(233)
plt.imshow(rend_img_overlay)
plt.title('3D Mesh overlay')
plt.axis('off')
plt.subplot(234)
plt.imshow(rend_img)
plt.title('3D mesh')
plt.axis('off')
plt.subplot(235)
plt.imshow(rend_img_vp1)
plt.title('diff vp')
plt.axis('off')
plt.subplot(236)
plt.imshow(rend_img_vp2)
plt.title('diff vp')
plt.axis('off')
plt.draw()
plt.savefig('./results/result_hmr.png')
def visualize(img, proc_param, joints, verts, cam):
"""
Renders the result in original image coordinate frame.
"""
cam_for_render, vert_shifted, joints_orig = vis_util.get_original(
proc_param, verts, cam, joints, img_size=img.shape[:2])
# Render results
skel_img = vis_util.draw_skeleton(img, joints_orig)
rend_img_overlay = renderer(vert_shifted,
cam=cam_for_render,
img=img,
do_alpha=True)
rend_img = renderer(vert_shifted,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp1 = renderer.rotated(vert_shifted,
60,
cam=cam_for_render,
img_size=img.shape[:2])
rend_img_vp2 = renderer.rotated(vert_shifted,
-60,
cam=cam_for_render,
img_size=img.shape[:2])
import matplotlib.pyplot as plt
# plt.ion()
plt.figure(1)
plt.clf()
plt.subplot(231)
plt.imshow(img)
plt.title('input')
plt.axis('off')
plt.subplot(232)
plt.imshow(skel_img)
plt.title('joint projection')
plt.axis('off')
plt.subplot(233)
plt.imshow(rend_img_overlay)
plt.title('3D Mesh overlay')
plt.axis('off')
plt.subplot(234)
plt.imshow(rend_img)
plt.title('3D mesh')
plt.axis('off')
plt.subplot(235)
plt.imshow(rend_img_vp1)
plt.title('diff vp')
plt.axis('off')
plt.subplot(236)
plt.imshow(rend_img_vp2)
plt.title('diff vp')
plt.axis('off')
path_directory = os.path.split(config.img_path)[0]
print(path_directory)
if (config.json_path == None):
plt.savefig(path_directory + '/processed_' +
os.path.split(config.img_path)[1])
else:
plt.savefig(path_directory + '/processed_openpose_' +
os.path.split(config.img_path)[1])
plt.draw()
plt.show()
