Source code for pytorch3d.renderer.camera_utils

# Copyright (c) Meta Platforms, Inc. and affiliates.
# All rights reserved.
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree.

# pyre-unsafe

from typing import Sequence, Tuple

import torch
from pytorch3d.transforms import Transform3d

from .cameras import CamerasBase

[docs] def camera_to_eye_at_up( world_to_view_transform: Transform3d, ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: """ Given a world to view transform, return the eye, at and up vectors which represent its position. For example, if cam is a camera object, then after running .. code-block:: from cameras import look_at_view_transform eye, at, up = camera_to_eye_at_up(cam.get_world_to_view_transform()) R, T = look_at_view_transform(eye=eye, at=at, up=up) any other camera created from R and T will have the same world to view transform as cam. Also, given a camera position R and T, then after running: .. code-block:: from cameras import get_world_to_view_transform, look_at_view_transform eye, at, up = camera_to_eye_at_up(get_world_to_view_transform(R=R, T=T)) R2, T2 = look_at_view_transform(eye=eye, at=at, up=up) R2 will equal R and T2 will equal T. Args: world_to_view_transform: Transform3d representing the extrinsic transformation of N cameras. Returns: eye: FloatTensor of shape [N, 3] representing the camera centers in world space. at: FloatTensor of shape [N, 3] representing points in world space directly in front of the cameras e.g. the positions of objects to be viewed by the cameras. up: FloatTensor of shape [N, 3] representing vectors in world space which when projected on to the camera plane point upwards. """ cam_trans = world_to_view_transform.inverse() # In the PyTorch3D right handed coordinate system, the camera in view space # is always at the origin looking along the +z axis. # The up vector is not a position so cannot be transformed with # transform_points. However the position eye+up above the camera # (whose position vector in the camera coordinate frame is an up vector) # can be transformed with transform_points. eye_at_up_view = torch.tensor( [[0, 0, 0], [0, 0, 1], [0, 1, 0]], dtype=torch.float32, device=cam_trans.device ) eye_at_up_world = cam_trans.transform_points(eye_at_up_view).reshape(-1, 3, 3) eye, at, up_plus_eye = eye_at_up_world.unbind(1) up = up_plus_eye - eye return eye, at, up
[docs] def rotate_on_spot( R: torch.Tensor, T: torch.Tensor, rotation: torch.Tensor ) -> Tuple[torch.Tensor, torch.Tensor]: """ Given a camera position as R and T (batched or not), and a rotation matrix (batched or not) return a new R and T representing camera position(s) in the same location but rotated on the spot by the given rotation. In particular the new world to view rotation will be the previous one followed by the inverse of the given rotation. For example, adding the following lines before constructing a camera will make the camera point a little to the right of where it otherwise would have been. .. code-block:: from math import radians from pytorch3d.transforms import axis_angle_to_matrix angles = [0, radians(10), 0] rotation = axis_angle_to_matrix(torch.FloatTensor(angles)) R, T = rotate_on_spot(R, T, rotation) Note here that if you have a column vector, then when you premultiply it by this `rotation` (see the rotation_conversions doc), then it will be rotated anticlockwise if facing the -y axis. In our context, where we postmultiply row vectors to transform them, `rotation` will rotate the camera clockwise around the -y axis (i.e. when looking down), which is a turn to the right. If angles was [radians(10), 0, 0], the camera would get pointed up a bit instead. If angles was [0, 0, radians(10)], the camera would be rotated anticlockwise a bit, so the image would appear rotated clockwise from how it otherwise would have been. If you want to translate the camera from the origin in camera coordinates, this is simple and does not need a separate function. In particular, a translation by X = [a, b, c] would cause the camera to move a units left, b units up, and c units forward. This is achieved by using T-X in place of T. Args: R: FloatTensor of shape [3, 3] or [N, 3, 3] T: FloatTensor of shape [3] or [N, 3] rotation: FloatTensor of shape [3, 3] or [n, 3, 3] where if neither n nor N is 1, then n and N must be equal. Returns: R: FloatTensor of shape [max(N, n), 3, 3] T: FloatTensor of shape [max(N, n), 3] """ if R.ndim == 2: R = R[None] if T.ndim == 1: T = T[None] if rotation.ndim == 2: rotation = rotation[None] if R.ndim != 3 or R.shape[1:] != (3, 3): raise ValueError("Invalid R") if T.ndim != 2 or T.shape[1] != 3: raise ValueError("Invalid T") if rotation.ndim != 3 or rotation.shape[1:] != (3, 3): raise ValueError("Invalid rotation") new_R = R @ rotation.transpose(1, 2) old_RT = torch.bmm(R, T[:, :, None]) new_T = torch.matmul(new_R.transpose(1, 2), old_RT)[:, :, 0] return new_R, new_T
[docs] def join_cameras_as_batch(cameras_list: Sequence[CamerasBase]) -> CamerasBase: """ Create a batched cameras object by concatenating a list of input cameras objects. All the tensor attributes will be joined along the batch dimension. Args: cameras_list: List of camera classes all of the same type and on the same device. Each represents one or more cameras. Returns: cameras: single batched cameras object of the same type as all the objects in the input list. """ # Get the type and fields to join from the first camera in the batch c0 = cameras_list[0] fields = c0._FIELDS shared_fields = c0._SHARED_FIELDS if not all(isinstance(c, CamerasBase) for c in cameras_list): raise ValueError("cameras in cameras_list must inherit from CamerasBase") if not all(type(c) is type(c0) for c in cameras_list[1:]): raise ValueError("All cameras must be of the same type") if not all(c.device == c0.device for c in cameras_list[1:]): raise ValueError("All cameras in the batch must be on the same device") # Concat the fields to make a batched tensor kwargs = {} kwargs["device"] = c0.device for field in fields: field_not_none = [(getattr(c, field) is not None) for c in cameras_list] if not any(field_not_none): continue if not all(field_not_none): raise ValueError(f"Attribute {field} is inconsistently present") attrs_list = [getattr(c, field) for c in cameras_list] if field in shared_fields: # Only needs to be set once if not all(a == attrs_list[0] for a in attrs_list): raise ValueError(f"Attribute {field} is not constant across inputs") # e.g. "in_ndc" is set as attribute "_in_ndc" on the class # but provided as "in_ndc" in the input args if field.startswith("_"): field = field[1:] kwargs[field] = attrs_list[0] elif isinstance(attrs_list[0], torch.Tensor): # In the init, all inputs will be converted to # batched tensors before set as attributes # Join as a tensor along the batch dimension kwargs[field] =, dim=0) else: raise ValueError(f"Field {field} type is not supported for batching") return c0.__class__(**kwargs)