Exemplo n.º 1
0
    def evaluate_joint(self, outs):
        print('Evaluation start...')
        sample_num = len(outs)

        mpjpe = np.zeros((sample_num, self.joint_num))  # pose error
        pampjpe = np.zeros((sample_num, self.joint_num))  # pose error

        for n in range(sample_num):
            out = outs[n]

            # render materials
            pose_coord_out, pose_coord_gt = out['joint_coord'], out[
                'joint_coord_target']

            # root joint alignment
            pose_coord_out, pose_coord_gt = pose_coord_out - pose_coord_out[:
                                                                            1], pose_coord_gt - pose_coord_gt[:
                                                                                                              1]

            # pose error calculate
            mpjpe[n] = np.sqrt(np.sum((pose_coord_out - pose_coord_gt)**2, 1))
            # perform rigid alignment
            pose_coord_out = rigid_align(pose_coord_out, pose_coord_gt)
            pampjpe[n] = np.sqrt(np.sum((pose_coord_out - pose_coord_gt)**2,
                                        1))

        # total pose error (H36M joint set)
        tot_err = np.mean(mpjpe)
        eval_summary = 'MPJPE (mm)    >> tot: %.2f\n' % (tot_err)
        print(eval_summary)

        tot_err = np.mean(pampjpe)
        eval_summary = 'PA-MPJPE (mm) >> tot: %.2f\n' % (tot_err)
        print(eval_summary)
Exemplo n.º 2
0
    def evaluate_joint(self, outs):
        print('Evaluation start...')
        annots = self.datalist
        assert len(annots) == len(outs)
        sample_num = len(annots)

        mpjpe = np.zeros((sample_num, len(self.human36_eval_joint)))
        pampjpe = np.zeros((sample_num, len(self.human36_eval_joint)))
        for n in range(sample_num):
            out = outs[n]
            annot = annots[n]

            # render materials
            pose_coord_out, pose_coord_gt = out['joint_coord'], annot['joint_cam']

            # root joint alignment
            pose_coord_out, pose_coord_gt = pose_coord_out - pose_coord_out[:1], pose_coord_gt - pose_coord_gt[:1]
            # sample eval joitns
            pose_coord_out, pose_coord_gt = pose_coord_out[self.human36_eval_joint, :], pose_coord_gt[self.human36_eval_joint, :]

            # pose error calculate
            mpjpe[n] = np.sqrt(np.sum((pose_coord_out - pose_coord_gt) ** 2, 1))
            # perform rigid alignment
            pose_coord_out = rigid_align(pose_coord_out, pose_coord_gt)
            pampjpe[n] = np.sqrt(np.sum((pose_coord_out - pose_coord_gt) ** 2, 1))

        # total pose error
        tot_err = np.mean(mpjpe)
        eval_summary = 'MPJPE (mm)    >> tot: %.2f\n' % (tot_err)
        print(eval_summary)

        tot_err = np.mean(pampjpe)
        eval_summary = 'PA-MPJPE (mm) >> tot: %.2f\n' % (tot_err)
        print(eval_summary)
Exemplo n.º 3
0
    def evaluate_joint(self, outs):
        print('Evaluation start...')
        annots = self.datalist
        assert len(annots) == len(outs)
        sample_num = len(annots)
        sample_num = len(outs)

        mpjpe = np.zeros((sample_num, self.coco_joint_num))  # pose error
        pa_mpjpe = np.zeros((sample_num, self.coco_joint_num))  # pose error

        for n in range(sample_num):
            out = outs[n]
            annot = annots[n]
            img_path = annot['img_path']

            joint_coord_out, joint_coord_gt = out['joint_coord'], out[
                'joint_coord_target']
            # root joint alignment, coco joint set
            joint_coord_out = joint_coord_out - joint_coord_out[-2:-1]
            joint_coord_gt = joint_coord_gt - joint_coord_gt[-2:-1]

            # pose error calculate
            mpjpe[n] = np.sqrt(np.sum((joint_coord_out - joint_coord_gt)**2,
                                      1))

            joint_coord_out_aligned = rigid_align(joint_coord_out,
                                                  joint_coord_gt)
            pa_mpjpe[n] = np.sqrt(
                np.sum((joint_coord_out_aligned - joint_coord_gt)**2, 1))

        tot_err = np.mean(mpjpe)
        eval_summary = 'COCO MPJPE (mm)    >> tot: %.2f\n' % (tot_err)
        print(eval_summary)

        tot_err = np.mean(pa_mpjpe)
        eval_summary = 'COCO PA-MPJPE (mm) >> tot: %.2f\n' % (tot_err)
        print(eval_summary)
Exemplo n.º 4
0
    def evaluate(self, outs):
        print('Evaluation start...')
        annots = self.datalist
        assert len(annots) == len(outs)
        sample_num = len(annots)
        sample_num = len(outs)

        mpjpe_h36m = np.zeros((sample_num, len(self.human36_eval_joint))) # pose error
        pampjpe_h36m = np.zeros((sample_num, len(self.human36_eval_joint))) # pose error

        mpjpe_smpl = np.zeros((sample_num, self.smpl_joint_num)) # pose error
        mpvpe = np.zeros((sample_num, self.smpl_vertex_num)) # mesh error
        pa_mpvpe = np.zeros((sample_num, self.smpl_vertex_num)) # mesh error

        pred_j3d, gt_j3d = [], []

        for n in range(sample_num):
            out = outs[n]
            annot = annots[n]
            img_path = annot['img_path']

            mesh_coord_out, mesh_coord_gt = out['mesh_coord'], out['mesh_coord_target']
            joint_coord_out, joint_coord_gt = np.dot(self.joint_regressor_smpl, mesh_coord_out), np.dot(self.joint_regressor_smpl, mesh_coord_gt)
            # root joint alignment
            coord_out_cam = np.concatenate((mesh_coord_out, joint_coord_out))
            coord_out_cam = coord_out_cam - coord_out_cam[self.smpl_vertex_num + self.smpl_root_joint_idx]
            coord_gt_cam = np.concatenate((mesh_coord_gt, joint_coord_gt))
            coord_gt_cam = coord_gt_cam - coord_gt_cam[self.smpl_vertex_num + self.smpl_root_joint_idx]
 
            # pose error calculate
            pose_coord_out = coord_out_cam[self.smpl_vertex_num:,:]
            pose_coord_gt = coord_gt_cam[self.smpl_vertex_num:,:]
            mpjpe_smpl[n] = np.sqrt(np.sum((pose_coord_out - pose_coord_gt)**2,1))

            # mesh error calculate
            mesh_coord_out = coord_out_cam[:self.smpl_vertex_num,:]
            mesh_coord_gt = coord_gt_cam[:self.smpl_vertex_num,:]
            mpvpe[n] = np.sqrt(np.sum((mesh_coord_out - mesh_coord_gt)**2,1))

            mesh_coord_out_aligned, _, _, _ = rigid_align(mesh_coord_out, mesh_coord_gt)
            pa_mpvpe[n] = np.sqrt(np.sum((mesh_coord_out_aligned - mesh_coord_gt)**2,1))

            # pose error of h36m calculate
            pose_coord_out_h36m = np.dot(self.mesh_model.joint_regressor_h36m, mesh_coord_out)
            pose_coord_out_h36m = pose_coord_out_h36m - pose_coord_out_h36m[self.human36_root_joint_idx]
            pose_coord_out_h36m = pose_coord_out_h36m[self.human36_eval_joint, :]
            pose_coord_gt_h36m = np.dot(self.mesh_model.joint_regressor_h36m, mesh_coord_gt)
            pose_coord_gt_h36m = pose_coord_gt_h36m - pose_coord_gt_h36m[self.human36_root_joint_idx]
            pose_coord_gt_h36m = pose_coord_gt_h36m[self.human36_eval_joint, :]

            pred_j3d.append(pose_coord_out_h36m); gt_j3d.append(pose_coord_gt_h36m)

            mpjpe_h36m[n] = np.sqrt(np.sum((pose_coord_out_h36m - pose_coord_gt_h36m)**2,1))
            pose_coord_out_h36m_aligned, _, _, _ = rigid_align(pose_coord_out_h36m, pose_coord_gt_h36m) # perform rigid alignment
            pampjpe_h36m[n] = np.sqrt(np.sum((pose_coord_out_h36m_aligned - pose_coord_gt_h36m)**2,1))

            vis = cfg.TEST.vis
            if vis and (n % 10):
                mesh_to_save = mesh_coord_out / 1000
                obj_path = osp.join(cfg.vis_dir, f'3dpw_{img_path}.obj')
                save_obj(mesh_to_save, self.mesh_model.face, obj_path)

        """
        print("--------Smoothed output errors--------")
        # print smoothed results
        # compute accel
        accel_error = []
        mpjpe_list = []
        pa_mpjpe_list = []
        pred_j3d, gt_j3d = np.array(pred_j3d), np.array(gt_j3d)
        for vid_idx in self.video_indices:
            pred, gt = pred_j3d[vid_idx], gt_j3d[vid_idx]
            pred = smooth_pose(pred, min_cutoff=0.004, beta=0.005)
            vid_acc_err = compute_error_accel(gt, pred)
            vid_acc_err = np.mean(vid_acc_err)
            accel_error.append(vid_acc_err)

            mpjpe = np.sqrt(np.sum((pred - gt)**2,2))
            mpjpe_list.append(np.mean(mpjpe))
            for idx in range(len(pred)):
                pa_pred, _, _, _ = rigid_align(pred[idx], gt[idx])
                pa_mpjpe = np.sqrt(np.sum((pa_pred - gt[idx])**2,1))
                pa_mpjpe_list.append(pa_mpjpe)

        accel_error = np.mean(accel_error)
        eval_summary = 'H36M accel error (mm/s^2): tot: %.2f\n' % (accel_error)
        print(eval_summary)

        tot_err = np.mean(mpjpe_list)
        eval_summary = 'H36M MPJPE (mm)    >> tot: %.2f\n' % (tot_err)
        print(eval_summary)

        tot_err = np.mean(pa_mpjpe_list)
        eval_summary = 'H36M PA-MPJPE (mm) >> tot: %.2f\n' % (tot_err)
        print(eval_summary)
        print("--------Original output errors--------")
        """


        # total pose error (H36M joint set)
        tot_err = np.mean(mpjpe_h36m)
        eval_summary = 'H36M MPJPE (mm)    >> tot: %.2f\n' % (tot_err)
        print(eval_summary)

        tot_err = np.mean(pampjpe_h36m)
        eval_summary = 'H36M PA-MPJPE (mm) >> tot: %.2f\n' % (tot_err)
        print(eval_summary)

        # total pose error (SMPL joint set)
        tot_err = np.mean(mpjpe_smpl)
        eval_summary = 'SMPL MPJPE (mm)    >> tot: %.2f\n' % (tot_err)
        print(eval_summary)

        # total mesh error
        tot_err = np.mean(mpvpe)
        eval_summary = 'MPVPE (mm)         >> tot: %.2f\n' % (tot_err)
        print(eval_summary)

        # total mesh error
        tot_err = np.mean(pa_mpvpe)
        eval_summary = 'PA-MPVPE (mm)      >> tot: %.2f\n' % (tot_err)
        print(eval_summary)
Exemplo n.º 5
0
    def evaluate(self, outs):
        print('Evaluation start...')
        annots = self.datalist
        # assert len(annots) == len(outs)
        # sample_num = len(annots)
        sample_num = len(outs)

        mpjpe_h36m = np.zeros(
            (sample_num, len(self.human36_eval_joint)))  # pose error
        pampjpe_h36m = np.zeros(
            (sample_num, len(self.human36_eval_joint)))  # pose error

        mpjpe_smpl = np.zeros((sample_num, self.smpl_joint_num))  # pose error
        mpvpe = np.zeros((sample_num, self.smpl_vertex_num))  # mesh error

        for n in range(sample_num):
            out = outs[n]
            annot = annots[n]

            mesh_coord_out, mesh_coord_gt = out['mesh_coord'], out[
                'mesh_coord_target']
            joint_coord_out, joint_coord_gt = np.dot(
                self.joint_regressor_smpl,
                mesh_coord_out), np.dot(self.joint_regressor_smpl,
                                        mesh_coord_gt)
            # root joint alignment
            coord_out_cam = np.concatenate((mesh_coord_out, joint_coord_out))
            coord_out_cam = coord_out_cam - coord_out_cam[
                self.smpl_vertex_num + self.smpl_root_joint_idx]
            coord_gt_cam = np.concatenate((mesh_coord_gt, joint_coord_gt))
            coord_gt_cam = coord_gt_cam - coord_gt_cam[
                self.smpl_vertex_num + self.smpl_root_joint_idx]

            # pose error calculate
            pose_coord_out = coord_out_cam[self.smpl_vertex_num:, :]
            pose_coord_gt = coord_gt_cam[self.smpl_vertex_num:, :]
            mpjpe_smpl[n] = np.sqrt(
                np.sum((pose_coord_out - pose_coord_gt)**2, 1))

            # mesh error calculate
            mesh_coord_out = coord_out_cam[:self.smpl_vertex_num, :]
            mesh_coord_gt = coord_gt_cam[:self.smpl_vertex_num, :]
            mpvpe[n] = np.sqrt(np.sum((mesh_coord_out - mesh_coord_gt)**2, 1))

            # pose error of h36m calculate
            pose_coord_out_h36m = np.dot(self.mesh_model.joint_regressor_h36m,
                                         mesh_coord_out)
            pose_coord_out_h36m = pose_coord_out_h36m - pose_coord_out_h36m[
                self.human36_root_joint_idx]
            pose_coord_out_h36m = pose_coord_out_h36m[
                self.human36_eval_joint, :]
            pose_coord_gt_h36m = np.dot(self.mesh_model.joint_regressor_h36m,
                                        mesh_coord_gt)

            pose_coord_gt_h36m = pose_coord_gt_h36m - pose_coord_gt_h36m[
                self.human36_root_joint_idx]
            pose_coord_gt_h36m = pose_coord_gt_h36m[self.human36_eval_joint, :]
            mpjpe_h36m[n] = np.sqrt(
                np.sum((pose_coord_out_h36m - pose_coord_gt_h36m)**2, 1))
            pose_coord_out_h36m = rigid_align(
                pose_coord_out_h36m,
                pose_coord_gt_h36m)  # perform rigid alignment
            pampjpe_h36m[n] = np.sqrt(
                np.sum((pose_coord_out_h36m - pose_coord_gt_h36m)**2, 1))

            vis = cfg.TEST.vis
            if vis and (n % 500):
                mesh_to_save = mesh_coord_out / 1000
                obj_path = osp.join(cfg.vis_dir, f'3dpw_{n}.obj')
                save_obj(mesh_to_save, self.mesh_model.face, obj_path)

        # total pose error (H36M joint set)
        tot_err = np.mean(mpjpe_h36m)
        eval_summary = 'H36M MPJPE (mm)    >> tot: %.2f\n' % (tot_err)
        print(eval_summary)

        tot_err = np.mean(pampjpe_h36m)
        eval_summary = 'H36M PA-MPJPE (mm) >> tot: %.2f\n' % (tot_err)
        print(eval_summary)

        # total pose error (SMPL joint set)
        tot_err = np.mean(mpjpe_smpl)
        eval_summary = 'SMPL MPJPE (mm)    >> tot: %.2f\n' % (tot_err)
        print(eval_summary)

        # total mesh error
        tot_err = np.mean(mpvpe)
        eval_summary = 'MPVPE (mm)         >> tot: %.2f\n' % (tot_err)
        print(eval_summary)
Exemplo n.º 6
0
    def evaluate(self, outs):
        print('Evaluation start...')
        annots = self.datalist
        assert len(annots) == len(outs)
        sample_num = len(outs)

        # eval H36M joints
        pose_error_h36m = np.zeros((sample_num, len(self.human36_eval_joint)))  # pose error
        pose_error_action_h36m = [[] for _ in range(len(self.action_name))]  # pose error for each sequence
        pose_pa_error_h36m = np.zeros((sample_num, len(self.human36_eval_joint)))  # pose error
        pose_pa_error_action_h36m = [[] for _ in range(len(self.action_name))]  # pose error for each sequence

        # eval SMPL joints and mesh vertices
        pose_error = np.zeros((sample_num, self.smpl_joint_num))  # pose error
        pose_error_action = [[] for _ in range(len(self.action_name))]  # pose error for each sequence
        mesh_error = np.zeros((sample_num, self.smpl_vertex_num))  # mesh error
        mesh_error_action = [[] for _ in range(len(self.action_name))]  # mesh error for each sequence
        for n in range(sample_num):
            annot = annots[n]
            out = outs[n]

            # render materials
            img_path = annot['img_path']
            obj_name = '_'.join(img_path.split('/')[-2:])[:-4]

            # root joint alignment
            mesh_coord_out, mesh_coord_gt = out['mesh_coord'], out['mesh_coord_target']
            joint_coord_out, joint_coord_gt = np.dot(self.joint_regressor_smpl, mesh_coord_out), np.dot(self.joint_regressor_smpl, mesh_coord_gt)
            mesh_coord_out = mesh_coord_out - joint_coord_out[self.smpl_root_joint_idx:self.smpl_root_joint_idx+1]
            mesh_coord_gt = mesh_coord_gt - joint_coord_gt[self.smpl_root_joint_idx:self.smpl_root_joint_idx+1]
            pose_coord_out = joint_coord_out - joint_coord_out[self.smpl_root_joint_idx:self.smpl_root_joint_idx+1]
            pose_coord_gt = joint_coord_gt - joint_coord_gt[self.smpl_root_joint_idx:self.smpl_root_joint_idx+1]

            # pose error calculate
            pose_error[n] = np.sqrt(np.sum((pose_coord_out - pose_coord_gt) ** 2, 1))
            img_name = annot['img_path']
            action_idx = int(img_name[img_name.find('act') + 4:img_name.find('act') + 6]) - 2
            pose_error_action[action_idx].append(pose_error[n].copy())

            # mesh error calculate
            mesh_error[n] = np.sqrt(np.sum((mesh_coord_out - mesh_coord_gt) ** 2, 1))
            img_name = annot['img_path']
            action_idx = int(img_name[img_name.find('act') + 4:img_name.find('act') + 6]) - 2
            mesh_error_action[action_idx].append(mesh_error[n].copy())

            # pose error of h36m calculate
            pose_coord_out_h36m = np.dot(self.joint_regressor_human36, mesh_coord_out)
            pose_coord_out_h36m = pose_coord_out_h36m - pose_coord_out_h36m[self.human36_root_joint_idx]
            pose_coord_out_h36m = pose_coord_out_h36m[self.human36_eval_joint, :]
            pose_coord_gt_h36m = annot['joint_cam']
            pose_coord_gt_h36m = pose_coord_gt_h36m - pose_coord_gt_h36m[self.human36_root_joint_idx]
            pose_coord_gt_h36m = pose_coord_gt_h36m[self.human36_eval_joint, :]
            pose_error_h36m[n] = np.sqrt(np.sum((pose_coord_out_h36m - pose_coord_gt_h36m) ** 2, 1))
            pose_coord_out_h36m = rigid_align(pose_coord_out_h36m, pose_coord_gt_h36m) # perform rigid alignment
            pose_pa_error_h36m[n] = np.sqrt(np.sum((pose_coord_out_h36m - pose_coord_gt_h36m) ** 2, 1))
            img_name = annot['img_path']
            action_idx = int(img_name[img_name.find('act') + 4:img_name.find('act') + 6]) - 2
            pose_error_action_h36m[action_idx].append(pose_error_h36m[n].copy())
            pose_pa_error_action_h36m[action_idx].append(pose_pa_error_h36m[n].copy())

            vis = cfg.TEST.vis
            if vis and (n % 500 == 0):
                mesh_to_save = mesh_coord_out / 1000
                obj_path = osp.join(cfg.vis_dir, f'{obj_name}.obj')
                save_obj(mesh_to_save, self.mesh_model.face, obj_path)

        # total pose error (H36M joint set)
        tot_err = np.mean(pose_error_h36m)
        metric = 'MPJPE'
        eval_summary = 'Protocol ' + str(self.protocol) + ' H36M pose error (' + metric + ') >> tot: %.2f\n' % (tot_err)
        # pose error for each action
        for i in range(len(pose_error_action_h36m)):
            err = np.mean(np.array(pose_error_action_h36m[i]))
            eval_summary += (self.action_name[i] + ': %.2f ' % err)
        print(eval_summary)

        tot_err = np.mean(pose_pa_error_h36m)
        metric = 'PA-MPJPE'
        eval_summary = 'Protocol ' + str(self.protocol) + ' H36M pose error (' + metric + ') >> tot: %.2f\n' % (tot_err)
        # pose error for each action
        for i in range(len(pose_pa_error_action_h36m)):
            err = np.mean(np.array(pose_pa_error_action_h36m[i]))
            eval_summary += (self.action_name[i] + ': %.2f ' % err)
        print(eval_summary)

        # total pose error (SMPL joint set)
        tot_err = np.mean(pose_error)
        metric = 'MPJPE'
        eval_summary = 'Protocol ' + str(self.protocol) + ' SMPL pose error (' + metric + ') >> tot: %.2f\n' % (tot_err)
        # pose error for each action
        for i in range(len(pose_error_action)):
            err = np.mean(np.array(pose_error_action[i]))
            eval_summary += (self.action_name[i] + ': %.2f ' % err)
        print(eval_summary)

        # total mesh error
        tot_err = np.mean(mesh_error)
        metric = 'MPVPE'
        eval_summary = 'Protocol ' + str(self.protocol) + ' SMPL mesh error (' + metric + ') >> tot: %.2f\n' % (tot_err)
        # mesh error for each action
        for i in range(len(mesh_error_action)):
            err = np.mean(np.array(mesh_error_action[i]))
            eval_summary += (self.action_name[i] + ': %.2f ' % err)
        print(eval_summary)