Download panogs/rendering/camera.py from SiddhuG01/PanoGS: direct link, hf CLI and curl.
- Browser
- Download file 4.61 kB
-
https://huggingface.co/spaces/SiddhuG01/PanoGS/resolve/main/panogs/rendering/camera.py
- Command line
-
hf download hf://spaces/SiddhuG01/PanoGS/panogs/rendering/camera.py
-
curl -L -o camera.py https://huggingface.co/spaces/SiddhuG01/PanoGS/resolve/main/panogs/rendering/camera.py
4.61 kB
| """ | |
| Camera model and viewpoint geometry for 3D Gaussian Splatting rendering. | |
| """ | |
| from dataclasses import dataclass | |
| from typing import Tuple, Union | |
| import numpy as np | |
| class Camera: | |
| """ | |
| Pinhole perspective camera for 3D scene rendering. | |
| Attributes: | |
| position: (3,) camera position in world space. | |
| R: (3, 3) World-to-Camera rotation matrix. | |
| t: (3,) World-to-Camera translation vector: x_cam = R @ x_world + t. | |
| width: Image width in pixels. | |
| height: Image height in pixels. | |
| fov_x: Horizontal field of view in degrees. | |
| fov_y: Vertical field of view in degrees. | |
| """ | |
| position: np.ndarray | |
| R: np.ndarray | |
| t: np.ndarray | |
| width: int | |
| height: int | |
| fov_x: float | |
| fov_y: float | |
| def fx(self) -> float: | |
| """Focal length along X in pixels.""" | |
| return float(self.width / (2.0 * np.tan(np.radians(self.fov_x) / 2.0))) | |
| def fy(self) -> float: | |
| """Focal length along Y in pixels.""" | |
| return float(self.height / (2.0 * np.tan(np.radians(self.fov_y) / 2.0))) | |
| def cx(self) -> float: | |
| """Principal point X in pixels.""" | |
| return float(self.width / 2.0) | |
| def cy(self) -> float: | |
| """Principal point Y in pixels.""" | |
| return float(self.height / 2.0) | |
| def world_to_camera(self, points: np.ndarray) -> np.ndarray: | |
| """ | |
| Transform 3D points from world space to camera space: | |
| p_cam = R @ p_world + t | |
| """ | |
| pts = np.asarray(points, dtype=np.float32) | |
| # (N, 3) @ (3, 3)^T + (3,) = (N, 3) | |
| return (np.matmul(pts, self.R.T) + self.t).astype(np.float32) | |
| def create_lookat_camera( | |
| eye: Tuple[float, float, float], | |
| target: Tuple[float, float, float] = (0.0, 0.0, 0.0), | |
| up: Tuple[float, float, float] = (0.0, 1.0, 0.0), | |
| width: int = 512, | |
| height: int = 512, | |
| fov: float = 60.0, | |
| ) -> Camera: | |
| """ | |
| Create a Camera looking from `eye` towards `target` with given `up` vector. | |
| Camera coordinate convention: | |
| +X: Right | |
| +Y: Down (image space) or Up (standard 3DGS view convention: camera looks along +Z, right +X, down +Y) | |
| +Z: Forward (towards scene) | |
| """ | |
| eye_pt = np.array(eye, dtype=np.float32) | |
| target_pt = np.array(target, dtype=np.float32) | |
| up_vec = np.array(up, dtype=np.float32) | |
| # Forward direction (+Z in camera space) | |
| forward = target_pt - eye_pt | |
| f_norm = np.linalg.norm(forward) | |
| if f_norm == 0: | |
| forward = np.array([0.0, 0.0, 1.0], dtype=np.float32) | |
| else: | |
| forward = forward / f_norm | |
| # Right direction (+X in camera space) | |
| right = np.cross(forward, up_vec) | |
| r_norm = np.linalg.norm(right) | |
| if r_norm == 0: | |
| right = np.array([1.0, 0.0, 0.0], dtype=np.float32) | |
| else: | |
| right = right / r_norm | |
| # True Up direction (-Y in screen space / +Y in camera view) | |
| cam_up = np.cross(right, forward) | |
| # Camera rotation matrix: rows are (right, -cam_up, forward) for standard screen Y down | |
| R = np.stack([right, -cam_up, forward], axis=0).astype(np.float32) | |
| t = (-np.matmul(R, eye_pt)).astype(np.float32) | |
| aspect = width / float(height) | |
| fov_x = fov | |
| fov_y = float(2.0 * np.degrees(np.arctan(np.tan(np.radians(fov) / 2.0) / aspect))) | |
| return Camera( | |
| position=eye_pt, | |
| R=R, | |
| t=t, | |
| width=width, | |
| height=height, | |
| fov_x=fov_x, | |
| fov_y=fov_y, | |
| ) | |
| def create_orbit_camera( | |
| target: Tuple[float, float, float] = (0.0, 0.0, 0.0), | |
| distance: float = 2.5, | |
| azimuth_deg: float = 0.0, | |
| elevation_deg: float = 0.0, | |
| width: int = 512, | |
| height: int = 512, | |
| fov: float = 60.0, | |
| ) -> Camera: | |
| """ | |
| Create an orbital Camera placed on a sphere around `target`. | |
| Args: | |
| target: 3D point the camera is looking at. | |
| distance: Distance from target in meters. | |
| azimuth_deg: Horizontal rotation around Y axis in degrees. | |
| elevation_deg: Vertical elevation angle in degrees (-89 to +89). | |
| width: Render width. | |
| height: Render height. | |
| fov: Field of view in degrees. | |
| """ | |
| az_rad = np.radians(azimuth_deg) | |
| el_rad = np.radians(np.clip(elevation_deg, -89.0, 89.0)) | |
| x = target[0] + distance * np.cos(el_rad) * np.sin(az_rad) | |
| y = target[1] + distance * np.sin(el_rad) | |
| z = target[2] + distance * np.cos(el_rad) * np.cos(az_rad) | |
| return create_lookat_camera( | |
| eye=(x, y, z), | |
| target=target, | |
| width=width, | |
| height=height, | |
| fov=fov, | |
| ) | |