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()