ww_index: window list, captions, lags and scripts to rebuild the WildWorld windows from upstream
a54e6a7 verified Download ww_index/scripts/proxykit36/proxykit/geometry.py from yuzhewu207/wizard-precoded: direct link, hf CLI and curl.
- Browser
- Download file 5.1 kB
-
https://huggingface.co/datasets/yuzhewu207/wizard-precoded/resolve/main/ww_index/scripts/proxykit36/proxykit/geometry.py
- Command line
-
hf download hf://datasets/yuzhewu207/wizard-precoded/ww_index/scripts/proxykit36/proxykit/geometry.py
-
curl -L -o geometry.py https://huggingface.co/datasets/yuzhewu207/wizard-precoded/resolve/main/ww_index/scripts/proxykit36/proxykit/geometry.py
5.1 kB
| """Camera and world geometry in the BOSSV2V convention. | |
| World: UE centimetres, X forward, Y right, Z up. A camera is (quaternion xyzw, position cm, horizontal FOV deg); the | |
| columns of rotation(q) are the camera's forward, right and up axes, with up = forward x right and right = up x forward | |
| (zero roll in all recordings). Images are 1280x720 unless stated otherwise. | |
| """ | |
| from dataclasses import dataclass | |
| import numpy as np | |
| UP = np.array([0.0, 0.0, 1.0]) | |
| def rotation(q): | |
| """Quaternion (x, y, z, w) -> 3x3 matrix; same formula as the dataset exporter.""" | |
| q = np.asarray(q, dtype=float) | |
| x, y, z, w = q / np.linalg.norm(q) | |
| return np.array([[1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w)], | |
| [2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w)], | |
| [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)]]) | |
| def quat_from_matrix(R): | |
| w = np.sqrt(max(0.0, 1 + R[0, 0] + R[1, 1] + R[2, 2])) / 2 | |
| x = np.copysign(np.sqrt(max(0.0, 1 + R[0, 0] - R[1, 1] - R[2, 2])) / 2, R[2, 1] - R[1, 2]) | |
| y = np.copysign(np.sqrt(max(0.0, 1 - R[0, 0] + R[1, 1] - R[2, 2])) / 2, R[0, 2] - R[2, 0]) | |
| z = np.copysign(np.sqrt(max(0.0, 1 - R[0, 0] - R[1, 1] + R[2, 2])) / 2, R[1, 0] - R[0, 1]) | |
| q = np.array([x, y, z, w]) | |
| return q / np.linalg.norm(q) | |
| def look_rotation(forward): | |
| """Zero-roll camera rotation looking along `forward`.""" | |
| f = np.asarray(forward, float); f = f / np.linalg.norm(f) | |
| r = np.cross(UP, f); r /= np.linalg.norm(r) | |
| return np.stack([f, r, np.cross(f, r)], axis=1) | |
| def rot_z(angle): | |
| c, s = np.cos(angle), np.sin(angle) | |
| return np.array([[c, -s, 0.0], [s, c, 0.0], [0.0, 0.0, 1.0]]) | |
| def rot_axis(axis, angle): | |
| """Rodrigues rotation matrix about an arbitrary axis.""" | |
| a = np.asarray(axis, float); a = a / np.linalg.norm(a) | |
| K = np.array([[0, -a[2], a[1]], [a[2], 0, -a[0]], [-a[1], a[0], 0]]) | |
| return np.eye(3) + np.sin(angle) * K + (1 - np.cos(angle)) * K @ K | |
| class Camera: | |
| position: np.ndarray # cm | |
| quat: np.ndarray # xyzw | |
| fov: float = 70.0 # horizontal degrees | |
| width: int = 1280 | |
| height: int = 720 | |
| def look_at(position, target, fov=70.0, width=1280, height=720): | |
| position = np.asarray(position, float) | |
| return Camera(position, quat_from_matrix(look_rotation(np.asarray(target, float) - position)), fov, width, height) | |
| def from_horizon(v_horizon, camera_height_cm=220.0, fov=70.0, yaw=0.0, xy=(0.0, 0.0), width=1280, height=720): | |
| """Camera guessed from a single image: the horizon's image row fixes the pitch (row above the centre = camera | |
| looks down), plus an assumed height above the ground (z = 0), FOV and facing yaw (rad about +Z).""" | |
| f = width / 2 / np.tan(np.radians(fov) / 2) | |
| pitch = np.arctan((height / 2 - v_horizon) / f) # > 0: horizon above centre -> camera pitched down | |
| fwd = np.array([np.cos(yaw) * np.cos(-pitch), np.sin(yaw) * np.cos(-pitch), np.sin(-pitch)]) | |
| pos = np.array([xy[0], xy[1], camera_height_cm], float) | |
| return Camera(pos, quat_from_matrix(look_rotation(fwd)), fov, width, height) | |
| def R(self): | |
| return rotation(self.quat) | |
| def focal(self): | |
| return self.width / 2 / np.tan(np.radians(self.fov) / 2) | |
| def transform(self): | |
| """10-vector as stored in states.npz camera_transforms: quat xyzw, position, 3 unused.""" | |
| return np.concatenate([self.quat, self.position, np.zeros(3)]) | |
| def project(self, pts): | |
| """World points (...,3) -> pixel (u, v) and camera-forward depth (cm).""" | |
| rel = np.asarray(pts, float) - self.position | |
| R = self.R | |
| x, y, z = rel @ R[:, 0], rel @ R[:, 1], rel @ R[:, 2] | |
| xs = np.maximum(x, 1e-6) | |
| return np.stack([self.width / 2 + self.focal * y / xs, self.height / 2 - self.focal * z / xs], -1), x | |
| def ray(self, u, v): | |
| R = self.R | |
| d = R[:, 0] + R[:, 1] * (u - self.width / 2) / self.focal - R[:, 2] * (v - self.height / 2) / self.focal | |
| return d / np.linalg.norm(d) | |
| def ground_point(self, u, v, ground_z=0.0): | |
| """Intersect the pixel ray with the plane z = ground_z (e.g. the pixel under a character's feet).""" | |
| d = self.ray(u, v) | |
| assert d[2] < -1e-6, "pixel is above the horizon; cannot place it on the ground" | |
| t = (ground_z - self.position[2]) / d[2] | |
| return self.position + t * d | |
| def height_at(self, world_point, v_top): | |
| """World height (cm) of a vertical extent standing at world_point whose top projects to image row v_top.""" | |
| _, depth = self.project(world_point) | |
| uv, _ = self.project(world_point) | |
| return float((uv[1] - v_top) * depth / self.focal) | |
| def in_view(self, pts, margin=0): | |
| uv, d = self.project(pts) | |
| return (d > 10) & (uv[..., 0] >= -margin) & (uv[..., 0] < self.width + margin) & (uv[..., 1] >= -margin) & (uv[..., 1] < self.height + margin) | |