|
import torch
|
|
import torch.nn.functional as F
|
|
import numpy as np
|
|
|
|
|
|
def pad_camera_extrinsics_4x4(extrinsics):
|
|
if extrinsics.shape[-2] == 4:
|
|
return extrinsics
|
|
padding = torch.tensor([[0, 0, 0, 1]]).to(extrinsics)
|
|
if extrinsics.ndim == 3:
|
|
padding = padding.unsqueeze(0).repeat(extrinsics.shape[0], 1, 1)
|
|
extrinsics = torch.cat([extrinsics, padding], dim=-2)
|
|
return extrinsics
|
|
|
|
|
|
def center_looking_at_camera_pose(camera_position: torch.Tensor, look_at: torch.Tensor = None, up_world: torch.Tensor = None):
|
|
"""
|
|
Create OpenGL camera extrinsics from camera locations and look-at position.
|
|
|
|
camera_position: (M, 3) or (3,)
|
|
look_at: (3)
|
|
up_world: (3)
|
|
return: (M, 3, 4) or (3, 4)
|
|
"""
|
|
|
|
if look_at is None:
|
|
look_at = torch.tensor([0, 0, 0], dtype=torch.float32)
|
|
if up_world is None:
|
|
up_world = torch.tensor([0, 0, 1], dtype=torch.float32)
|
|
if camera_position.ndim == 2:
|
|
look_at = look_at.unsqueeze(0).repeat(camera_position.shape[0], 1)
|
|
up_world = up_world.unsqueeze(0).repeat(camera_position.shape[0], 1)
|
|
|
|
|
|
z_axis = camera_position - look_at
|
|
z_axis = F.normalize(z_axis, dim=-1).float()
|
|
x_axis = torch.linalg.cross(up_world, z_axis, dim=-1)
|
|
x_axis = F.normalize(x_axis, dim=-1).float()
|
|
y_axis = torch.linalg.cross(z_axis, x_axis, dim=-1)
|
|
y_axis = F.normalize(y_axis, dim=-1).float()
|
|
|
|
extrinsics = torch.stack([x_axis, y_axis, z_axis, camera_position], dim=-1)
|
|
extrinsics = pad_camera_extrinsics_4x4(extrinsics)
|
|
return extrinsics
|
|
|
|
|
|
def spherical_camera_pose(azimuths: np.ndarray, elevations: np.ndarray, radius=2.5):
|
|
azimuths = np.deg2rad(azimuths)
|
|
elevations = np.deg2rad(elevations)
|
|
|
|
xs = radius * np.cos(elevations) * np.cos(azimuths)
|
|
ys = radius * np.cos(elevations) * np.sin(azimuths)
|
|
zs = radius * np.sin(elevations)
|
|
|
|
cam_locations = np.stack([xs, ys, zs], axis=-1)
|
|
cam_locations = torch.from_numpy(cam_locations).float()
|
|
|
|
c2ws = center_looking_at_camera_pose(cam_locations)
|
|
return c2ws
|
|
|
|
|
|
def get_circular_camera_poses(M=120, radius=2.5, elevation=30.0):
|
|
|
|
|
|
|
|
|
|
assert M > 0 and radius > 0
|
|
|
|
elevation = np.deg2rad(elevation)
|
|
|
|
camera_positions = []
|
|
for i in range(M):
|
|
azimuth = 2 * np.pi * i / M
|
|
x = radius * np.cos(elevation) * np.cos(azimuth)
|
|
y = radius * np.cos(elevation) * np.sin(azimuth)
|
|
z = radius * np.sin(elevation)
|
|
camera_positions.append([x, y, z])
|
|
camera_positions = np.array(camera_positions)
|
|
camera_positions = torch.from_numpy(camera_positions).float()
|
|
extrinsics = center_looking_at_camera_pose(camera_positions)
|
|
return extrinsics
|
|
|
|
|
|
def FOV_to_intrinsics(fov, device='cpu'):
|
|
"""
|
|
Creates a 3x3 camera intrinsics matrix from the camera field of view, specified in degrees.
|
|
Note the intrinsics are returned as normalized by image size, rather than in pixel units.
|
|
Assumes principal point is at image center.
|
|
"""
|
|
focal_length = 0.5 / np.tan(np.deg2rad(fov) * 0.5)
|
|
intrinsics = torch.tensor([[focal_length, 0, 0.5], [0, focal_length, 0.5], [0, 0, 1]], device=device)
|
|
return intrinsics
|
|
|
|
|
|
def get_zero123plus_input_cameras(batch_size=1, radius=4.0, fov=30.0):
|
|
"""
|
|
Get the input camera parameters.
|
|
"""
|
|
azimuths = np.array([30, 90, 150, 210, 270, 330]).astype(float)
|
|
elevations = np.array([20, -10, 20, -10, 20, -10]).astype(float)
|
|
|
|
c2ws = spherical_camera_pose(azimuths, elevations, radius)
|
|
c2ws = c2ws.float().flatten(-2)
|
|
|
|
Ks = FOV_to_intrinsics(fov).unsqueeze(0).repeat(6, 1, 1).float().flatten(-2)
|
|
|
|
extrinsics = c2ws[:, :12]
|
|
intrinsics = torch.stack([Ks[:, 0], Ks[:, 4], Ks[:, 2], Ks[:, 5]], dim=-1)
|
|
cameras = torch.cat([extrinsics, intrinsics], dim=-1)
|
|
|
|
return cameras.unsqueeze(0).repeat(batch_size, 1, 1)
|
|
|
