cameras

class pytorch3d.renderer.cameras.CamerasBase(dtype=torch.float32, device='cpu', **kwargs)[source]

Bases: pytorch3d.renderer.utils.TensorProperties

CamerasBase implements a base class for all cameras.

For cameras, there are four different coordinate systems (or spaces) - World coordinate system: This is the system the object lives - the world. - Camera view coordinate system: This is the system that has its origin on the image plane

and the and the Z-axis perpendicular to the image plane. In PyTorch3D, we assume that +X points left, and +Y points up and +Z points out from the image plane. The transformation from world -> view happens after applying a rotation (R) and translation (T)
  • NDC coordinate system: This is the normalized coordinate system that confines
    in a volume the renderered part of the object or scene. Also known as view volume. Given the PyTorch3D convention, (+1, +1, znear) is the top left near corner, and (-1, -1, zfar) is the bottom right far corner of the volume. The transformation from view -> NDC happens after applying the camera projection matrix (P).
  • Screen coordinate system: This is another representation of the view volume with
    the XY coordinates defined in pixel space instead of a normalized space.

A better illustration of the coordinate systems can be found in pytorch3d/docs/notes/cameras.md.

It defines methods that are common to all camera models:
  • get_camera_center that returns the optical center of the camera in
    world coordinates
  • get_world_to_view_transform which returns a 3D transform from
    world coordinates to the camera view coordinates (R, T)
  • get_full_projection_transform which composes the projection
    transform (P) with the world-to-view transform (R, T)
  • transform_points which takes a set of input points in world coordinates and
    projects to NDC coordinates ranging from [-1, -1, znear] to [+1, +1, zfar].
  • transform_points_screen which takes a set of input points in world coordinates and
    projects them to the screen coordinates ranging from [0, 0, znear] to [W-1, H-1, zfar]

For each new camera, one should implement the get_projection_transform routine that returns the mapping from camera view coordinates to NDC coordinates.

Another useful function that is specific to each camera model is unproject_points which sends points from NDC coordinates back to camera view or world coordinates depending on the world_coordinates boolean argument of the function.

get_projection_transform()[source]

Calculate the projective transformation matrix.

Parameters:**kwargs – parameters for the projection can be passed in as keyword arguments to override the default values set in __init__.
Returns:a Transform3d object which represents a batch of projection matrices of shape (N, 3, 3)
unproject_points()[source]

Transform input points from NDC coodinates to the world / camera coordinates.

Each of the input points xy_depth of shape (…, 3) is a concatenation of the x, y location and its depth.

For instance, for an input 2D tensor of shape (num_points, 3) xy_depth takes the following form:

xy_depth[i] = [x[i], y[i], depth[i]],

for a each point at an index i.

The following example demonstrates the relationship between transform_points and unproject_points:

cameras = # camera object derived from CamerasBase
xyz = # 3D points of shape (batch_size, num_points, 3)
# transform xyz to the camera view coordinates
xyz_cam = cameras.get_world_to_view_transform().transform_points(xyz)
# extract the depth of each point as the 3rd coord of xyz_cam
depth = xyz_cam[:, :, 2:]
# project the points xyz to the camera
xy = cameras.transform_points(xyz)[:, :, :2]
# append depth to xy
xy_depth = torch.cat((xy, depth), dim=2)
# unproject to the world coordinates
xyz_unproj_world = cameras.unproject_points(xy_depth, world_coordinates=True)
print(torch.allclose(xyz, xyz_unproj_world)) # True
# unproject to the camera coordinates
xyz_unproj = cameras.unproject_points(xy_depth, world_coordinates=False)
print(torch.allclose(xyz_cam, xyz_unproj)) # True
Parameters:
  • xy_depth – torch tensor of shape (…, 3).
  • world_coordinates – If True, unprojects the points back to world coordinates using the camera extrinsics R and T. False ignores R and T and unprojects to the camera view coordinates.
Returns
new_points: unprojected points with the same shape as xy_depth.
get_camera_center(**kwargs) → torch.Tensor[source]

Return the 3D location of the camera optical center in the world coordinates.

Parameters:**kwargs – parameters for the camera extrinsics can be passed in as keyword arguments to override the default values set in __init__.

Setting T here will update the values set in init as this value may be needed later on in the rendering pipeline e.g. for lighting calculations.

Returns:C – a batch of 3D locations of shape (N, 3) denoting the locations of the center of each camera in the batch.
get_world_to_view_transform(**kwargs) → pytorch3d.transforms.transform3d.Transform3d[source]

Return the world-to-view transform.

Parameters:**kwargs – parameters for the camera extrinsics can be passed in as keyword arguments to override the default values set in __init__.

Setting R and T here will update the values set in init as these values may be needed later on in the rendering pipeline e.g. for lighting calculations.

Returns:A Transform3d object which represents a batch of transforms of shape (N, 3, 3)
get_full_projection_transform(**kwargs) → pytorch3d.transforms.transform3d.Transform3d[source]

Return the full world-to-NDC transform composing the world-to-view and view-to-NDC transforms.

Parameters:**kwargs – parameters for the projection transforms can be passed in as keyword arguments to override the default values set in __init__.

Setting R and T here will update the values set in init as these values may be needed later on in the rendering pipeline e.g. for lighting calculations.

Returns:a Transform3d object which represents a batch of transforms of shape (N, 3, 3)
transform_points(points, eps: Optional[float] = None, **kwargs) → torch.Tensor[source]

Transform input points from world to NDC space.

Parameters:
  • points – torch tensor of shape (…, 3).
  • eps

    If eps!=None, the argument is used to clamp the divisor in the homogeneous normalization of the points transformed to the ndc space. Please see transforms.Transform3D.transform_points for details.

    For CamerasBase.transform_points, setting eps > 0 stabilizes gradients since it leads to avoiding division by excessivelly low numbers for points close to the camera plane.

Returns
new_points: transformed points with the same shape as the input.
transform_points_screen(points, image_size, eps: Optional[float] = None, **kwargs) → torch.Tensor[source]

Transform input points from world to screen space.

Parameters:
  • points – torch tensor of shape (N, V, 3).
  • image_size – torch tensor of shape (N, 2)
  • eps

    If eps!=None, the argument is used to clamp the divisor in the homogeneous normalization of the points transformed to the ndc space. Please see transforms.Transform3D.transform_points for details.

    For CamerasBase.transform_points, setting eps > 0 stabilizes gradients since it leads to avoiding division by excessivelly low numbers for points close to the camera plane.

Returns
new_points: transformed points with the same shape as the input.
clone()[source]

Returns a copy of self.

is_perspective()[source]
get_znear()[source]
pytorch3d.renderer.cameras.OpenGLPerspectiveCameras(znear=1.0, zfar=100.0, aspect_ratio=1.0, fov=60.0, degrees: bool = True, R=tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]]), T=tensor([[0., 0., 0.]]), device='cpu')[source]

OpenGLPerspectiveCameras has been DEPRECATED. Use FoVPerspectiveCameras instead. Preserving OpenGLPerspectiveCameras for backward compatibility.

class pytorch3d.renderer.cameras.FoVPerspectiveCameras(znear=1.0, zfar=100.0, aspect_ratio=1.0, fov=60.0, degrees: bool = True, R=tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]]), T=tensor([[0., 0., 0.]]), K=None, device='cpu')[source]

Bases: pytorch3d.renderer.cameras.CamerasBase

A class which stores a batch of parameters to generate a batch of projection matrices by specifiying the field of view. The definition of the parameters follow the OpenGL perspective camera.

The extrinsics of the camera (R and T matrices) can also be set in the initializer or passed in to get_full_projection_transform to get the full transformation from world -> ndc.

The transform_points method calculates the full world -> ndc transform and then applies it to the input points.

The transforms can also be returned separately as Transform3d objects.

  • Setting the Aspect Ratio for Non Square Images *

If the desired output image size is non square (i.e. a tuple of (H, W) where H != W) the aspect ratio needs special consideration: There are two aspect ratios to be aware of:

  • the aspect ratio of each pixel
  • the aspect ratio of the output image

The aspect_ratio setting in the FoVPerspectiveCameras sets the pixel aspect ratio. When using this camera with the differentiable rasterizer be aware that in the rasterizer we assume square pixels, but allow variable image aspect ratio (i.e rectangle images).

In most cases you will want to set the camera aspect_ratio=1.0 (i.e. square pixels) and only vary the output image dimensions in pixels for rasterization.

__init__(znear=1.0, zfar=100.0, aspect_ratio=1.0, fov=60.0, degrees: bool = True, R=tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]]), T=tensor([[0., 0., 0.]]), K=None, device='cpu')[source]
Parameters:
  • znear – near clipping plane of the view frustrum.
  • zfar – far clipping plane of the view frustrum.
  • aspect_ratio – aspect ratio of the image pixels. 1.0 indicates square pixels.
  • fov – field of view angle of the camera.
  • degrees – bool, set to True if fov is specified in degrees.
  • R – Rotation matrix of shape (N, 3, 3)
  • T – Translation matrix of shape (N, 3)
  • K – (optional) A calibration matrix of shape (N, 4, 4) If provided, don’t need znear, zfar, fov, aspect_ratio, degrees
  • device – torch.device or string
compute_projection_matrix(znear, zfar, fov, aspect_ratio, degrees) → torch.Tensor[source]

Compute the calibration matrix K of shape (N, 4, 4)

Parameters:
  • znear – near clipping plane of the view frustrum.
  • zfar – far clipping plane of the view frustrum.
  • fov – field of view angle of the camera.
  • aspect_ratio – aspect ratio of the image pixels. 1.0 indicates square pixels.
  • degrees – bool, set to True if fov is specified in degrees.
Returns:

torch.floatTensor of the calibration matrix with shape (N, 4, 4)

get_projection_transform(**kwargs) → pytorch3d.transforms.transform3d.Transform3d[source]

Calculate the perpective projection matrix with a symmetric viewing frustrum. Use column major order. The viewing frustrum will be projected into ndc, s.t. (max_x, max_y) -> (+1, +1) (min_x, min_y) -> (-1, -1)

Parameters:**kwargs – parameters for the projection can be passed in as keyword arguments to override the default values set in __init__.
Returns:a Transform3d object which represents a batch of projection matrices of shape (N, 4, 4)
h1 = (max_y + min_y)/(max_y - min_y)
w1 = (max_x + min_x)/(max_x - min_x)
tanhalffov = tan((fov/2))
s1 = 1/tanhalffov
s2 = 1/(tanhalffov * (aspect_ratio))

# To map z to the range [0, 1] use:
f1 =  far / (far - near)
f2 = -(far * near) / (far - near)

# Projection matrix
K = [
        [s1,   0,   w1,   0],
        [0,   s2,   h1,   0],
        [0,    0,   f1,  f2],
        [0,    0,    1,   0],
]
unproject_points(xy_depth: torch.Tensor, world_coordinates: bool = True, scaled_depth_input: bool = False, **kwargs) → torch.Tensor[source]

>! FoV cameras further allow for passing depth in world units (scaled_depth_input=False) or in the [0, 1]-normalized units (scaled_depth_input=True)

Parameters:scaled_depth_input – If True, assumes the input depth is in the [0, 1]-normalized units. If False the input depth is in the world units.
is_perspective()[source]
pytorch3d.renderer.cameras.OpenGLOrthographicCameras(znear=1.0, zfar=100.0, top=1.0, bottom=-1.0, left=-1.0, right=1.0, scale_xyz=((1.0, 1.0, 1.0),), R=tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]]), T=tensor([[0., 0., 0.]]), device='cpu')[source]

OpenGLOrthographicCameras has been DEPRECATED. Use FoVOrthographicCameras instead. Preserving OpenGLOrthographicCameras for backward compatibility.

class pytorch3d.renderer.cameras.FoVOrthographicCameras(znear=1.0, zfar=100.0, max_y=1.0, min_y=-1.0, max_x=1.0, min_x=-1.0, scale_xyz=((1.0, 1.0, 1.0),), R=tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]]), T=tensor([[0., 0., 0.]]), K=None, device='cpu')[source]

Bases: pytorch3d.renderer.cameras.CamerasBase

A class which stores a batch of parameters to generate a batch of projection matrices by specifiying the field of view. The definition of the parameters follow the OpenGL orthographic camera.

__init__(znear=1.0, zfar=100.0, max_y=1.0, min_y=-1.0, max_x=1.0, min_x=-1.0, scale_xyz=((1.0, 1.0, 1.0),), R=tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]]), T=tensor([[0., 0., 0.]]), K=None, device='cpu')[source]
Parameters:
  • znear – near clipping plane of the view frustrum.
  • zfar – far clipping plane of the view frustrum.
  • max_y – maximum y coordinate of the frustrum.
  • min_y – minimum y coordinate of the frustrum.
  • max_x – maximum x coordinate of the frustrum.
  • min_x – minumum x coordinage of the frustrum
  • scale_xyz – scale factors for each axis of shape (N, 3).
  • R – Rotation matrix of shape (N, 3, 3).
  • T – Translation of shape (N, 3).
  • K – (optional) A calibration matrix of shape (N, 4, 4) If provided, don’t need znear, zfar, max_y, min_y, max_x, min_x, scale_xyz
  • device – torch.device or string.

Only need to set min_x, max_x, min_y, max_y for viewing frustrums which are non symmetric about the origin.

compute_projection_matrix(znear, zfar, max_x, min_x, max_y, min_y, scale_xyz) → torch.Tensor[source]

Compute the calibration matrix K of shape (N, 4, 4)

Parameters:
  • znear – near clipping plane of the view frustrum.
  • zfar – far clipping plane of the view frustrum.
  • max_x – maximum x coordinate of the frustrum.
  • min_x – minumum x coordinage of the frustrum
  • max_y – maximum y coordinate of the frustrum.
  • min_y – minimum y coordinate of the frustrum.
  • scale_xyz – scale factors for each axis of shape (N, 3).
get_projection_transform(**kwargs) → pytorch3d.transforms.transform3d.Transform3d[source]

Calculate the orthographic projection matrix. Use column major order.

Parameters:**kwargs – parameters for the projection can be passed in to override the default values set in __init__.
Returns:
a Transform3d object which represents a batch of projection
matrices of shape (N, 4, 4)
scale_x = 2 / (max_x - min_x)
scale_y = 2 / (max_y - min_y)
scale_z = 2 / (far-near)
mid_x = (max_x + min_x) / (max_x - min_x)
mix_y = (max_y + min_y) / (max_y - min_y)
mid_z = (far + near) / (far−near)

K = [
        [scale_x,        0,         0,  -mid_x],
        [0,        scale_y,         0,  -mix_y],
        [0,              0,  -scale_z,  -mid_z],
        [0,              0,         0,       1],
]
unproject_points(xy_depth: torch.Tensor, world_coordinates: bool = True, scaled_depth_input: bool = False, **kwargs) → torch.Tensor[source]

>! FoV cameras further allow for passing depth in world units (scaled_depth_input=False) or in the [0, 1]-normalized units (scaled_depth_input=True)

Parameters:scaled_depth_input – If True, assumes the input depth is in the [0, 1]-normalized units. If False the input depth is in the world units.
is_perspective()[source]
pytorch3d.renderer.cameras.SfMPerspectiveCameras(focal_length=1.0, principal_point=((0.0, 0.0),), R=tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]]), T=tensor([[0., 0., 0.]]), device='cpu')[source]

SfMPerspectiveCameras has been DEPRECATED. Use PerspectiveCameras instead. Preserving SfMPerspectiveCameras for backward compatibility.

class pytorch3d.renderer.cameras.PerspectiveCameras(focal_length=1.0, principal_point=((0.0, 0.0),), R=tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]]), T=tensor([[0., 0., 0.]]), K=None, device='cpu', image_size=((-1, -1),))[source]

Bases: pytorch3d.renderer.cameras.CamerasBase

A class which stores a batch of parameters to generate a batch of transformation matrices using the multi-view geometry convention for perspective camera.

Parameters for this camera can be specified in NDC or in screen space. If you wish to provide parameters in screen space, you NEED to provide the image_size = (imwidth, imheight). If you wish to provide parameters in NDC space, you should NOT provide image_size. Providing valid image_size will triger a screen space to NDC space transformation in the camera.

For example, here is how to define cameras on the two spaces.

__init__(focal_length=1.0, principal_point=((0.0, 0.0),), R=tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]]), T=tensor([[0., 0., 0.]]), K=None, device='cpu', image_size=((-1, -1),))[source]
Parameters:
  • focal_length – Focal length of the camera in world units. A tensor of shape (N, 1) or (N, 2) for square and non-square pixels respectively.
  • principal_point – xy coordinates of the center of the principal point of the camera in pixels. A tensor of shape (N, 2).
  • R – Rotation matrix of shape (N, 3, 3)
  • T – Translation matrix of shape (N, 3)
  • K – (optional) A calibration matrix of shape (N, 4, 4) If provided, don’t need focal_length, principal_point, image_size
  • device – torch.device or string
  • image_size – If image_size = (imwidth, imheight) with imwidth, imheight > 0 is provided, the camera parameters are assumed to be in screen space. They will be converted to NDC space. If image_size is not provided, the parameters are assumed to be in NDC space.
get_projection_transform(**kwargs) → pytorch3d.transforms.transform3d.Transform3d[source]

Calculate the projection matrix using the multi-view geometry convention.

Parameters:**kwargs – parameters for the projection can be passed in as keyword arguments to override the default values set in __init__.
Returns:A Transform3d object with a batch of N projection transforms.
fx = focal_length[:, 0]
fy = focal_length[:, 1]
px = principal_point[:, 0]
py = principal_point[:, 1]

K = [
        [fx,   0,   px,   0],
        [0,   fy,   py,   0],
        [0,    0,    0,   1],
        [0,    0,    1,   0],
]
unproject_points(xy_depth: torch.Tensor, world_coordinates: bool = True, **kwargs) → torch.Tensor[source]
is_perspective()[source]
pytorch3d.renderer.cameras.SfMOrthographicCameras(focal_length=1.0, principal_point=((0.0, 0.0),), R=tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]]), T=tensor([[0., 0., 0.]]), device='cpu')[source]

SfMOrthographicCameras has been DEPRECATED. Use OrthographicCameras instead. Preserving SfMOrthographicCameras for backward compatibility.

class pytorch3d.renderer.cameras.OrthographicCameras(focal_length=1.0, principal_point=((0.0, 0.0),), R=tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]]), T=tensor([[0., 0., 0.]]), K=None, device='cpu', image_size=((-1, -1),))[source]

Bases: pytorch3d.renderer.cameras.CamerasBase

A class which stores a batch of parameters to generate a batch of transformation matrices using the multi-view geometry convention for orthographic camera.

Parameters for this camera can be specified in NDC or in screen space. If you wish to provide parameters in screen space, you NEED to provide the image_size = (imwidth, imheight). If you wish to provide parameters in NDC space, you should NOT provide image_size. Providing valid image_size will triger a screen space to NDC space transformation in the camera.

For example, here is how to define cameras on the two spaces.

__init__(focal_length=1.0, principal_point=((0.0, 0.0),), R=tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]]), T=tensor([[0., 0., 0.]]), K=None, device='cpu', image_size=((-1, -1),))[source]
Parameters:
  • focal_length – Focal length of the camera in world units. A tensor of shape (N, 1) or (N, 2) for square and non-square pixels respectively.
  • principal_point – xy coordinates of the center of the principal point of the camera in pixels. A tensor of shape (N, 2).
  • R – Rotation matrix of shape (N, 3, 3)
  • T – Translation matrix of shape (N, 3)
  • K – (optional) A calibration matrix of shape (N, 4, 4) If provided, don’t need focal_length, principal_point, image_size
  • device – torch.device or string
  • image_size – If image_size = (imwidth, imheight) with imwidth, imheight > 0 is provided, the camera parameters are assumed to be in screen space. They will be converted to NDC space. If image_size is not provided, the parameters are assumed to be in NDC space.
get_projection_transform(**kwargs) → pytorch3d.transforms.transform3d.Transform3d[source]

Calculate the projection matrix using the multi-view geometry convention.

Parameters:**kwargs – parameters for the projection can be passed in as keyword arguments to override the default values set in __init__.
Returns:A Transform3d object with a batch of N projection transforms.
fx = focal_length[:,0]
fy = focal_length[:,1]
px = principal_point[:,0]
py = principal_point[:,1]

K = [
        [fx,   0,    0,  px],
        [0,   fy,    0,  py],
        [0,    0,    1,   0],
        [0,    0,    0,   1],
]
unproject_points(xy_depth: torch.Tensor, world_coordinates: bool = True, **kwargs) → torch.Tensor[source]
is_perspective()[source]
pytorch3d.renderer.cameras.get_world_to_view_transform(R=tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]]), T=tensor([[0., 0., 0.]])) → pytorch3d.transforms.transform3d.Transform3d[source]

This function returns a Transform3d representing the transformation matrix to go from world space to view space by applying a rotation and a translation.

PyTorch3D uses the same convention as Hartley & Zisserman. I.e., for camera extrinsic parameters R (rotation) and T (translation), we map a 3D point X_world in world coordinates to a point X_cam in camera coordinates with: X_cam = X_world R + T

Parameters:
  • R – (N, 3, 3) matrix representing the rotation.
  • T – (N, 3) matrix representing the translation.
Returns:

a Transform3d object which represents the composed RT transformation.

pytorch3d.renderer.cameras.camera_position_from_spherical_angles(distance, elevation, azimuth, degrees: bool = True, device: str = 'cpu') → torch.Tensor[source]

Calculate the location of the camera based on the distance away from the target point, the elevation and azimuth angles.

Parameters:
  • distance – distance of the camera from the object.
  • azimuth (elevation,) –

    angles. The inputs distance, elevation and azimuth can be one of the following

    • Python scalar
    • Torch scalar
    • Torch tensor of shape (N) or (1)
  • degrees – bool, whether the angles are specified in degrees or radians.
  • device – str or torch.device, device for new tensors to be placed on.

The vectors are broadcast against each other so they all have shape (N, 1).

Returns:camera_position – (N, 3) xyz location of the camera.
pytorch3d.renderer.cameras.look_at_rotation(camera_position, at=((0, 0, 0), ), up=((0, 1, 0), ), device: str = 'cpu') → torch.Tensor[source]

This function takes a vector ‘camera_position’ which specifies the location of the camera in world coordinates and two vectors at and up which indicate the position of the object and the up directions of the world coordinate system respectively. The object is assumed to be centered at the origin.

The output is a rotation matrix representing the transformation from world coordinates -> view coordinates.

Parameters:
  • camera_position – position of the camera in world coordinates
  • at – position of the object in world coordinates
  • up – vector specifying the up direction in the world coordinate frame.
The inputs camera_position, at and up can each be a
  • 3 element tuple/list
  • torch tensor of shape (1, 3)
  • torch tensor of shape (N, 3)

The vectors are broadcast against each other so they all have shape (N, 3).

Returns:R – (N, 3, 3) batched rotation matrices
pytorch3d.renderer.cameras.look_at_view_transform(dist=1.0, elev=0.0, azim=0.0, degrees: bool = True, eye: Optional[Sequence[T_co]] = None, at=((0, 0, 0), ), up=((0, 1, 0), ), device='cpu') → Tuple[torch.Tensor, torch.Tensor][source]

This function returns a rotation and translation matrix to apply the ‘Look At’ transformation from world -> view coordinates [0].

Parameters:
  • dist – distance of the camera from the object
  • elev – angle in degres or radians. This is the angle between the vector from the object to the camera, and the horizontal plane y = 0 (xz-plane).
  • azim – angle in degrees or radians. The vector from the object to the camera is projected onto a horizontal plane y = 0. azim is the angle between the projected vector and a reference vector at (0, 0, 1) on the reference plane (the horizontal plane).
  • elem and azim can be of shape (dist,) –
  • degrees – boolean flag to indicate if the elevation and azimuth angles are specified in degrees or radians.
  • eye – the position of the camera(s) in world coordinates. If eye is not None, it will overide the camera position derived from dist, elev, azim.
  • up – the direction of the x axis in the world coordinate system.
  • at – the position of the object(s) in world coordinates.
  • up and at can be of shape (eye,) –
Returns:

2-element tuple containing

  • R: the rotation to apply to the points to align with the camera.
  • T: the translation to apply to the points to align with the camera.

References: [0] https://www.scratchapixel.com