| | |
| | |
| | |
| | |
| | |
| | |
| |
|
| | import math |
| |
|
| | import numpy as np |
| | import torch |
| |
|
| |
|
| | def generate_rotation_matrix_y(degrees): |
| | """ |
| | Generates a rotation matrix for rotation around the Y-axis by a given angle in degrees. |
| | |
| | Args: |
| | degrees (float): The rotation angle in degrees. |
| | |
| | Returns: |
| | numpy.ndarray: A 3x3 rotation matrix representing rotation about the Y-axis. |
| | """ |
| |
|
| | theta = math.radians(degrees) |
| | cos_theta = math.cos(theta) |
| | sin_theta = math.sin(theta) |
| |
|
| | R = [[cos_theta, 0, sin_theta], [0, 1, 0], [-sin_theta, 0, cos_theta]] |
| |
|
| | return np.asarray(R, dtype=np.float32) |
| |
|
| |
|
| | def getWorld2View2(R, t, translate=np.array([0.0, 0.0, 0.0]), scale=1.0): |
| | """ |
| | Computes the world-to-view (camera) transformation matrix. |
| | |
| | Args: |
| | R (numpy.ndarray): A 3x3 rotation matrix. |
| | t (numpy.ndarray): A 3-element translation vector. |
| | translate (numpy.ndarray, optional): Additional translation to apply to the camera center after transformation. Defaults to np.array([0.0, 0.0, 0.0]). |
| | scale (float, optional): Scaling factor for the camera center position. Defaults to 1.0. |
| | |
| | Returns: |
| | numpy.ndarray: A 4x4 world-to-view transformation matrix suitable for use in computer graphics pipelines. |
| | """ |
| |
|
| | Rt = np.zeros((4, 4)) |
| | Rt[:3, :3] = R.transpose() |
| | Rt[:3, 3] = t |
| | Rt[3, 3] = 1.0 |
| |
|
| | C2W = np.linalg.inv(Rt) |
| | cam_center = C2W[:3, 3] |
| | cam_center = (cam_center + translate) * scale |
| | C2W[:3, 3] = cam_center |
| | Rt = np.linalg.inv(C2W) |
| | return np.float32(Rt) |
| |
|
| |
|
| | def getProjectionMatrix(znear, zfar, fovX, fovY): |
| | """ |
| | Constructs a perspective projection matrix. |
| | |
| | Args: |
| | znear (float): The near clipping plane distance. |
| | zfar (float): The far clipping plane distance. |
| | fovX (float): The horizontal field of view in radians. |
| | fovY (float): The vertical field of view in radians. |
| | |
| | Returns: |
| | torch.Tensor: A 4x4 projection matrix suitable for 3D rendering. |
| | """ |
| |
|
| | tanHalfFovY = math.tan((fovY / 2)) |
| | tanHalfFovX = math.tan((fovX / 2)) |
| |
|
| | top = tanHalfFovY * znear |
| | bottom = -top |
| | right = tanHalfFovX * znear |
| | left = -right |
| |
|
| | P = torch.zeros(4, 4) |
| |
|
| | z_sign = 1.0 |
| |
|
| | P[0, 0] = 2.0 * znear / (right - left) |
| | P[1, 1] = 2.0 * znear / (top - bottom) |
| | P[0, 2] = (right + left) / (right - left) |
| | P[1, 2] = (top + bottom) / (top - bottom) |
| | P[3, 2] = z_sign |
| | P[2, 2] = z_sign * zfar / (zfar - znear) |
| | P[2, 3] = -(zfar * znear) / (zfar - znear) |
| | return P |
| |
|
| |
|
| | def intrinsic_to_fov(intrinsic, w, h): |
| | fx, fy = intrinsic[0, 0], intrinsic[1, 1] |
| | fov_x = 2 * torch.arctan2(w, 2 * fx) |
| | fov_y = 2 * torch.arctan2(h, 2 * fy) |
| | return fov_x, fov_y |
| |
|
| |
|
| | class Camera: |
| | """ |
| | Camera class for representing a pinhole or perspective camera model. |
| | |
| | Attributes: |
| | FoVx (float): Horizontal field of view in radians. |
| | FoVy (float): Vertical field of view in radians. |
| | height (int): Image height in pixels. |
| | width (int): Image width in pixels. |
| | world_view_transform (torch.Tensor): 4x4 matrix transforming world coordinates to camera (view) coordinates. |
| | zfar (float): Far clipping plane distance. |
| | znear (float): Near clipping plane distance. |
| | trans (np.ndarray): Camera translation vector applied after transformation. |
| | scale (float): Scale factor applied to the camera center. |
| | projection_matrix (torch.Tensor): 4x4 projection matrix for camera intrinsics. |
| | full_proj_transform (torch.Tensor): Combined view and projection transform matrix. |
| | camera_center (torch.Tensor): 3D location of the camera center in world coordinates. |
| | intrinsic (torch.Tensor): Camera intrinsic matrix. |
| | |
| | Methods: |
| | from_c2w(c2w, intrinsic, height, width): |
| | Instantiates a Camera object from a camera-to-world matrix and intrinsics. |
| | """ |
| |
|
| | def __init__( |
| | self, |
| | w2c, |
| | intrinsic, |
| | FoVx, |
| | FoVy, |
| | height, |
| | width, |
| | trans=np.array([0.0, 0.0, 0.0]), |
| | scale=1.0, |
| | ) -> None: |
| | """ |
| | Initializes the Camera object with extrinsics, intrinsics, field of view and additional parameters. |
| | |
| | Args: |
| | w2c (torch.Tensor): 4x4 world-to-camera extrinsic transformation matrix (transposed and used as view transform). |
| | intrinsic (torch.Tensor): 3x3 camera intrinsic matrix. |
| | FoVx (float): Horizontal field of view in radians. |
| | FoVy (float): Vertical field of view in radians. |
| | height (int): Image height in pixels. |
| | width (int): Image width in pixels. |
| | trans (np.ndarray, optional): Camera translation vector to apply after other transforms (default: [0.0, 0.0, 0.0]). |
| | scale (float, optional): Scale factor applied to the camera center (default: 1.0). |
| | """ |
| |
|
| | self.FoVx = FoVx |
| | self.FoVy = FoVy |
| | self.height = height |
| | self.width = width |
| | self.world_view_transform = w2c.transpose(0, 1) |
| |
|
| | self.zfar = 100.0 |
| | self.znear = 0.01 |
| |
|
| | self.trans = trans |
| | self.scale = scale |
| |
|
| | self.projection_matrix = ( |
| | getProjectionMatrix( |
| | znear=self.znear, zfar=self.zfar, fovX=self.FoVx, fovY=self.FoVy |
| | ) |
| | .transpose(0, 1) |
| | .to(w2c.device) |
| | ) |
| | self.full_proj_transform = ( |
| | self.world_view_transform.unsqueeze(0).bmm( |
| | self.projection_matrix.unsqueeze(0) |
| | ) |
| | ).squeeze(0) |
| | self.camera_center = self.world_view_transform.inverse()[3, :3] |
| |
|
| | self.intrinsic = intrinsic |
| |
|
| | @staticmethod |
| | def from_c2w(c2w, intrinsic, height, width): |
| | """ |
| | Creates a Camera object from a camera-to-world (c2w) matrix and intrinsic parameters. |
| | |
| | Args: |
| | c2w (torch.Tensor): 4x4 camera-to-world extrinsic matrix. |
| | intrinsic (torch.Tensor): 3x3 camera intrinsic matrix. |
| | height (int): Image height in pixels. |
| | width (int): Image width in pixels. |
| | |
| | Returns: |
| | Camera: An instance of the Camera class constructed from the provided parameters. |
| | """ |
| |
|
| | w2c = torch.inverse(c2w) |
| | FoVx, FoVy = intrinsic_to_fov( |
| | intrinsic, |
| | w=torch.tensor(width, device=w2c.device), |
| | h=torch.tensor(height, device=w2c.device), |
| | ) |
| |
|
| | return Camera( |
| | w2c=w2c, |
| | intrinsic=intrinsic, |
| | FoVx=FoVx, |
| | FoVy=FoVy, |
| | height=height, |
| | width=width, |
| | ) |
| |
|
| | @staticmethod |
| | def from_c2w_center_modfied(c2w, intrinsic, height, width): |
| | """ |
| | Creates a Camera object from a camera-to-world (c2w) matrix and intrinsic parameters, |
| | but modifies the intrinsic matrix so that the principal point is set to the image center. |
| | |
| | Args: |
| | c2w (torch.Tensor): 4x4 camera-to-world extrinsic matrix. |
| | intrinsic (torch.Tensor): 3x3 camera intrinsic matrix. |
| | height (int): Image height in pixels. |
| | width (int): Image width in pixels. |
| | |
| | Returns: |
| | Camera: An instance of the Camera class constructed from the provided parameters, with adjusted intrinsic center. |
| | """ |
| |
|
| | w2c = torch.inverse(c2w) |
| | intrinsic = intrinsic.clone() |
| |
|
| | intrinsic[0, 2] = width / 2.0 |
| | intrinsic[1, 2] = height / 2.0 |
| |
|
| | FoVx, FoVy = intrinsic_to_fov( |
| | intrinsic, |
| | w=torch.tensor(width, device=w2c.device), |
| | h=torch.tensor(height, device=w2c.device), |
| | ) |
| |
|
| | return Camera( |
| | w2c=w2c, |
| | intrinsic=intrinsic, |
| | FoVx=FoVx, |
| | FoVy=FoVy, |
| | height=height, |
| | width=width, |
| | ) |
| |
|
