envs/distracting_control/camera.py

# coding=utf-8
# Copyright 2021 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Lint as: python3
"""A wrapper for dm_control environments which applies camera distractions."""

import copy
from dm_control.rl import control
import numpy as np

CAMERA_MODES = ['fixed', 'track', 'trackcom', 'targetbody', 'targetbodycom']


def eul2mat(theta):
    """Converts euler angles (x, y, z) to a rotation matrix."""

    return np.array([
        [
            np.cos(theta[1]) * np.cos(theta[2]),
            np.sin(theta[0]) * np.sin(theta[1]) * np.cos(theta[2]) -
            np.sin(theta[2]) * np.cos(theta[0]),
            np.sin(theta[1]) * np.cos(theta[0]) * np.cos(theta[2]) +
            np.sin(theta[0]) * np.sin(theta[2])
        ],
        [
            np.sin(theta[2]) * np.cos(theta[1]),
            np.sin(theta[0]) * np.sin(theta[1]) * np.sin(theta[2]) +
            np.cos(theta[0]) * np.cos(theta[2]),
            np.sin(theta[1]) * np.sin(theta[2]) * np.cos(theta[0]) -
            np.sin(theta[0]) * np.cos(theta[2])
        ],
        [
            -np.sin(theta[1]),
            np.sin(theta[0]) * np.cos(theta[1]),
            np.cos(theta[0]) * np.cos(theta[1])
        ],
    ])


def _mat_from_theta(cos_theta, sin_theta, a):
    """Builds a rotation matrix from theta and an orientation vector."""

    row1 = [
        cos_theta + a[0] ** 2. * (1. - cos_theta),
        a[0] * a[1] * (1 - cos_theta) - a[2] * sin_theta,
        a[0] * a[2] * (1 - cos_theta) + a[1] * sin_theta
    ]
    row2 = [
        a[1] * a[0] * (1 - cos_theta) + a[2] * sin_theta,
        cos_theta + a[1] ** 2. * (1 - cos_theta),
        a[1] * a[2] * (1. - cos_theta) - a[0] * sin_theta
    ]
    row3 = [
        a[2] * a[0] * (1. - cos_theta) - a[1] * sin_theta,
        a[2] * a[1] * (1. - cos_theta) + a[0] * sin_theta,
        cos_theta + (a[2] ** 2.) * (1. - cos_theta)
    ]
    return np.stack([row1, row2, row3])


def rotvec2mat(theta, vec):
    """Converts a rotation around a vector to a rotation matrix."""

    a = vec / np.sqrt(np.sum(vec ** 2.))
    sin_theta = np.sin(theta)
    cos_theta = np.cos(theta)

    return _mat_from_theta(cos_theta, sin_theta, a)


def get_lookat_xmat_no_roll(agent_pos, camera_pos):
    """Solves for the cam rotation centering the agent with 0 roll."""

    # NOTE(austinstone): This method leads to wild oscillations around the north
    # and south polls.
    # For example, if agent is at (0., 0., 0.) and the camera is at (.01, 0., 1.),
    # this will produce a yaw of 90 degrees whereas if the camera is slightly
    # adjacent at (-.01, 0., 1.) this will produce a yaw of -90 degrees. I'm
    # not sure what the fix is, as this seems like the behavior we want in all
    # environments except for reacher.
    delta_vec = agent_pos - camera_pos
    delta_vec /= np.sqrt(np.sum(delta_vec ** 2.))
    yaw = np.arctan2(delta_vec[0], delta_vec[1])
    pitch = np.arctan2(delta_vec[2], np.sqrt(np.sum(delta_vec[:2] ** 2.)))
    pitch += np.pi / 2.  # Camera starts out looking at [0, 0, -1.]
    return eul2mat([pitch, 0., -yaw]).flatten()


def get_lookat_xmat(agent_pos, camera_pos):
    """Solves for the cam rotation centering the agent, allowing roll."""

    # Solve for the rotation which centers the agent in the scene.
    delta_vec = agent_pos - camera_pos
    delta_vec /= np.sqrt(np.sum(delta_vec ** 2.))
    y_vec = np.array([0., 0., -1.])  # This is where the cam starts from.
    a = np.cross(y_vec, delta_vec)
    sin_theta = np.sqrt(np.sum(a ** 2.))
    cos_theta = np.dot(delta_vec, y_vec)
    a /= (np.sqrt(np.sum(a ** 2.)) + .0001)
    return _mat_from_theta(cos_theta, sin_theta, a)


def cart2sphere(cart):
    r = np.sqrt(np.sum(cart ** 2.))
    h_angle = np.arctan2(cart[1], cart[0])
    v_angle = np.arctan2(np.sqrt(np.sum(cart[:2] ** 2.)), cart[2])
    return np.array([r, h_angle, v_angle])


def sphere2cart(sphere):
    r, h_angle, v_angle = sphere
    x = r * np.sin(v_angle) * np.cos(h_angle)
    y = r * np.sin(v_angle) * np.sin(h_angle)
    z = r * np.cos(v_angle)
    return np.array([x, y, z])


def clip_cam_position(position, min_radius, max_radius, min_h_angle,
                      max_h_angle, min_v_angle, max_v_angle):
    new_position = [-1., -1., -1.]
    new_position[0] = np.clip(position[0], min_radius, max_radius)
    new_position[1] = np.clip(position[1], min_h_angle, max_h_angle)
    new_position[2] = np.clip(position[2], min_v_angle, max_v_angle)
    return new_position


def get_lookat_point(physics, camera_id):
    """Get the point that the camera is looking at.

  It is assumed that the "point" the camera looks at the agent distance
  away and projected along the camera viewing matrix.

  Args:
    physics: mujoco physics objects
    camera_id: int

  Returns:
    position: float32 np.array of length 3
  """
    dist_to_agent = physics.named.data.cam_xpos[
                        camera_id] - physics.named.data.subtree_com[1]
    dist_to_agent = np.sqrt(np.sum(dist_to_agent ** 2.))
    initial_viewing_mat = copy.deepcopy(physics.named.data.cam_xmat[camera_id])
    initial_viewing_mat = np.reshape(initial_viewing_mat, (3, 3))
    z_vec = np.array([0., 0., -dist_to_agent])
    rotated_vec = np.dot(initial_viewing_mat, z_vec)
    return rotated_vec + physics.named.data.cam_xpos[camera_id]


class DistractingCameraEnv(control.Environment):
    """Environment wrapper for camera pose visual distraction.

  **NOTE**: This wrapper should be applied BEFORE the pixel wrapper to make sure
  the camera pose changes are applied before rendering occurs.
  """

    def __init__(self,
                 env,
                 camera_id,
                 horizontal_delta,
                 vertical_delta,
                 max_vel,
                 vel_std,
                 roll_delta,
                 max_roll_vel,
                 roll_std,
                 max_zoom_in_percent,
                 max_zoom_out_percent,
                 limit_to_upper_quadrant=False,
                 seed=None,
                 fixed=False,
                 ):
        self._env = env
        self._camera_id = camera_id
        self._horizontal_delta = horizontal_delta
        self._vertical_delta = vertical_delta

        self._horizontal_delta = horizontal_delta
        self._vertical_delta = vertical_delta
        self._max_vel = max_vel
        self._vel_std = vel_std
        self._roll_delta = roll_delta
        self._max_roll_vel = max_roll_vel
        self._roll_vel_std = roll_std
        self._max_zoom_in_percent = max_zoom_in_percent
        self._max_zoom_out_percent = max_zoom_out_percent
        self._limit_to_upper_quadrant = limit_to_upper_quadrant

        self._random_state = np.random.RandomState(seed=seed)

        # These camera state parameters will be set on the first reset call.
        self._camera_type = None
        self._camera_initial_lookat_point = None

        self._camera_vel = None
        self._max_h_angle = None
        self._max_v_angle = None
        self._min_h_angle = None
        self._min_v_angle = None
        self._radius = None
        self._roll_vel = None
        self._vel_scaling = None

        self.fixed = fixed
        self.first_reset = False

    def setup_camera(self):
        """Set up camera motion ranges and state."""
        # Define boundaries on the range of the camera motion.
        mode = self._env._physics.model.cam_mode[0]

        camera_type = CAMERA_MODES[mode]
        assert camera_type in ['fixed', 'trackcom']

        self._camera_type = camera_type
        self._cam_initial_lookat_point = get_lookat_point(self._env.physics,
                                                          self._camera_id)

        start_pos = copy.deepcopy(
            self._env.physics.named.data.cam_xpos[self._camera_id])

        if self._camera_type != 'fixed':
            # Center the camera relative to the agent's center of mass.
            start_pos -= self._env.physics.named.data.subtree_com[1]

        start_r, start_h_angle, start_v_angle = cart2sphere(start_pos)
        # Scale the velocity by the starting radius. Most environments have radius 4,
        # but this downscales the velocity for the envs with radius < 4.
        self._vel_scaling = start_r / 4.
        self._max_h_angle = start_h_angle + self._horizontal_delta
        self._min_h_angle = start_h_angle - self._horizontal_delta
        self._max_v_angle = start_v_angle + self._vertical_delta
        self._min_v_angle = start_v_angle - self._vertical_delta

        if self._limit_to_upper_quadrant:
            # A centered cam is at np.pi / 2.
            self._max_v_angle = min(self._max_v_angle, np.pi / 2.)
            self._min_v_angle = max(self._min_v_angle, 0.)
            # A centered cam is at -np.pi / 2.
            self._max_h_angle = min(self._max_h_angle, 0.)
            self._min_h_angle = max(self._min_h_angle, -np.pi)

        self._max_roll = self._roll_delta
        self._min_roll = -self._roll_delta
        self._min_radius = max(start_r - start_r * self._max_zoom_in_percent, 0.)
        self._max_radius = start_r + start_r * self._max_zoom_out_percent

        # Decide the starting position for the camera.
        self._h_angle = self._random_state.uniform(self._min_h_angle,
                                                   self._max_h_angle)

        self._v_angle = self._random_state.uniform(self._min_v_angle,
                                                   self._max_v_angle)

        self._radius = self._random_state.uniform(self._min_radius,
                                                  self._max_radius)

        self._roll = self._random_state.uniform(self._min_roll, self._max_roll)

        # Decide the starting velocity for the camera.
        vel = self._random_state.randn(3)
        vel /= np.sqrt(np.sum(vel ** 2.))
        vel *= self._random_state.uniform(0., self._max_vel)
        self._camera_vel = vel
        self._roll_vel = self._random_state.uniform(-self._max_roll_vel,
                                                    self._max_roll_vel)

    def reset(self):
        """Reset the camera state. """
        time_step = self._env.reset()
        if not self.fixed or not self.first_reset:
            self.setup_camera()
            self.first_reset = True
        self._apply()
        return time_step

    def step(self, action):
        time_step = self._env.step(action)

        if time_step.first():
            self.setup_camera()

        self._apply()
        return time_step

    def _apply(self):
        if not self._camera_type:
            self.setup_camera()

        # Random walk the velocity.
        vel_delta = self._random_state.randn(3)
        self._camera_vel += vel_delta * self._vel_std * self._vel_scaling
        self._roll_vel += self._random_state.randn() * self._roll_vel_std

        # Clip velocity if it gets too big.
        vel_norm = np.sqrt(np.sum(self._camera_vel ** 2.))
        if vel_norm > self._max_vel * self._vel_scaling:
            self._camera_vel *= (self._max_vel * self._vel_scaling) / vel_norm

        self._roll_vel = np.clip(self._roll_vel, -self._max_roll_vel,
                                 self._max_roll_vel)

        cart_cam_pos = sphere2cart([self._radius, self._h_angle, self._v_angle])
        # Apply velocity vector to camera
        sphere_cam_pos2 = cart2sphere(cart_cam_pos + self._camera_vel)
        sphere_cam_pos2 = clip_cam_position(sphere_cam_pos2, self._min_radius,
                                            self._max_radius, self._min_h_angle,
                                            self._max_h_angle, self._min_v_angle,
                                            self._max_v_angle)

        self._camera_vel = sphere2cart(sphere_cam_pos2) - cart_cam_pos

        self._radius, self._h_angle, self._v_angle = sphere_cam_pos2

        roll2 = self._roll + self._roll_vel
        roll2 = np.clip(roll2, self._min_roll, self._max_roll)

        self._roll_vel = roll2 - self._roll
        self._roll = roll2

        cart_cam_pos = sphere2cart(sphere_cam_pos2)

        if self._limit_to_upper_quadrant:
            lookat_method = get_lookat_xmat_no_roll
        else:
            # This method avoids jitteriness at the pole but allows some roll
            # in the camera matrix. This is important for reacher.
            lookat_method = get_lookat_xmat

        if self._camera_type == 'fixed':
            lookat_mat = lookat_method(self._cam_initial_lookat_point,
                                       cart_cam_pos)
        else:
            # Go from agent centric to world coords
            cart_cam_pos += self._env.physics.named.data.subtree_com[1]
            lookat_mat = lookat_method(
                get_lookat_point(self._env.physics, self._camera_id), cart_cam_pos)

        lookat_mat = np.reshape(lookat_mat, (3, 3))
        roll_mat = rotvec2mat(self._roll, np.array([0., 0., 1.]))
        xmat = np.dot(lookat_mat, roll_mat)
        self._env.physics.named.data.cam_xpos[self._camera_id] = cart_cam_pos
        self._env.physics.named.data.cam_xmat[self._camera_id] = xmat.flatten()

    # Forward property and method calls to self._env.
    def __getattr__(self, attr):
        if hasattr(self._env, attr):
            return getattr(self._env, attr)
        raise AttributeError("'{}' object has no attribute '{}'".format(
            type(self).__name__, attr))