Method build_face_mean

detrsmpl/models/utils/SMPLX.py:566–615

Builds the initial point for the iterative regressor of the face.

(self, global_orient, body_pose, betas, raw_jaw_pose,
                        expression, batch_size)

        self.face_cropper = CropSampler(crop_size)

    def build_face_mean(self, global_orient, body_pose, betas, raw_jaw_pose,
                        expression, batch_size):
        """Builds the initial point for the iterative regressor of the face."""
        face_mean = []
        # Compute the absolute pose of the right wrist
        neck_pose_abs = find_joint_global_rotation(self.neck_kin_chain,
                                                   global_orient, body_pose)
        # Convert the absolute neck pose to offsets
        neck_pose = neck_pose_abs[:, :3, :2].contiguous().reshape(
            batch_size, -1)

        camera_mean = self.model_head.get_mean('camera', batch_size=batch_size)

        neck_pose_condition = (neck_pose if self.condition_face_neck_pose else
                               self.model_head.get_mean('global_orient',
                                                        batch_size=batch_size))

        jaw_pose_condition = (raw_jaw_pose.reshape(batch_size, -1)
                              if self.condition_face_jaw_pose else
                              self.model_head.get_mean('jaw_pose',
                                                       batch_size=batch_size))
        face_num_betas = self.model_head.get_num_betas()
        shape_padding_size = face_num_betas - self.num_betas
        betas_condition = (
            F.pad(betas.reshape(batch_size, -1),
                  (0, shape_padding_size)) if self.condition_face_shape else
            self.model_head.get_mean('shape', batch_size=batch_size))

        face_num_expression_coeffs = self.model_head.get_num_expression_coeffs(
        )
        expr_padding_size = face_num_expression_coeffs \
            - self.num_expression_coeffs
        expression_condition = (
            F.pad(expression.reshape(batch_size, -1),
                  (0, expr_padding_size)) if self.condition_face_expression
            else self.model_head.get_mean('expression', batch_size=batch_size))

        # Should be Bx(Head pose params)
        face_mean.append(
            torch.cat([
                neck_pose_condition,
                jaw_pose_condition,
                betas_condition,
                expression_condition,
                camera_mean.reshape(batch_size, -1),
            ],
                      dim=1))

        face_mean = torch.cat(face_mean, dim=0)
        return face_mean

    def __call__(self, body_predictions, img_metas):
        """Function