Download realcase/34/move_replace_mesh_v2/code/bbox.py from FrontRear/VLMdataset: direct link, hf CLI and curl.
- Browser
- Download file 7.01 kB
-
https://huggingface.co/datasets/FrontRear/VLMdataset/resolve/main/realcase/34/move_replace_mesh_v2/code/bbox.py
- Command line
-
hf download hf://datasets/FrontRear/VLMdataset/realcase/34/move_replace_mesh_v2/code/bbox.py
-
curl -L -o bbox.py https://huggingface.co/datasets/FrontRear/VLMdataset/resolve/main/realcase/34/move_replace_mesh_v2/code/bbox.py
7.01 kB
| """Render ordinary world-space oriented bounding boxes as lamp proxies.""" | |
| from __future__ import annotations | |
| import json | |
| from dataclasses import dataclass | |
| from pathlib import Path | |
| from typing import Iterable, List, Sequence, Tuple | |
| import cv2 | |
| import numpy as np | |
| try: | |
| from .gaussian import camera_rays, quaternion_xyzw_to_matrix | |
| except ImportError: # Direct script execution. | |
| from gaussian import camera_rays, quaternion_xyzw_to_matrix | |
| class OrientedBoundingBox: | |
| identifier: str | |
| center_xyz: np.ndarray | |
| size_xyz: np.ndarray | |
| rotation_world: np.ndarray | |
| color_rgb: np.ndarray | |
| def half_size(self) -> np.ndarray: | |
| return 0.5 * self.size_xyz | |
| def vertices_world(self) -> np.ndarray: | |
| signs = np.array( | |
| [ | |
| [-1, -1, -1], [1, -1, -1], [1, 1, -1], [-1, 1, -1], | |
| [-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1], | |
| ], | |
| dtype=np.float64, | |
| ) | |
| local = signs * self.half_size | |
| return local @ self.rotation_world.T + self.center_xyz | |
| BOX_EDGES = ( | |
| (0, 1), (1, 2), (2, 3), (3, 0), | |
| (4, 5), (5, 6), (6, 7), (7, 4), | |
| (0, 4), (1, 5), (2, 6), (3, 7), | |
| ) | |
| def load_boxes(path: Path | str) -> Tuple[List[OrientedBoundingBox], dict]: | |
| with Path(path).open("r", encoding="utf-8") as handle: | |
| document = json.load(handle) | |
| default_color = document.get("color_rgb", [255, 48, 220]) | |
| raw_boxes = document.get("boxes") | |
| if not isinstance(raw_boxes, list) or not raw_boxes: | |
| raise ValueError("Bounding-box JSON must contain a non-empty 'boxes' list.") | |
| boxes = [] | |
| for index, item in enumerate(raw_boxes): | |
| center = np.asarray(item.get("center_xyz"), dtype=np.float64) | |
| size = np.asarray(item.get("size_xyz"), dtype=np.float64) | |
| color = np.asarray(item.get("color_rgb", default_color), dtype=np.float64) | |
| if center.shape != (3,) or size.shape != (3,) or color.shape != (3,): | |
| raise ValueError( | |
| f"Box {index}: center_xyz, size_xyz and color_rgb must each contain 3 values." | |
| ) | |
| if not np.isfinite(center).all() or not np.isfinite(size).all() or np.any(size <= 0): | |
| raise ValueError(f"Box {index}: center and positive size must be finite.") | |
| if not np.isfinite(color).all() or np.any(color < 0) or np.any(color > 255): | |
| raise ValueError(f"Box {index}: color_rgb must be in [0,255].") | |
| boxes.append( | |
| OrientedBoundingBox( | |
| identifier=str(item.get("id", f"lamp_{index}")), | |
| center_xyz=center, | |
| size_xyz=size, | |
| rotation_world=quaternion_xyzw_to_matrix( | |
| item.get("rotation_xyzw", [0.0, 0.0, 0.0, 1.0]) | |
| ), | |
| color_rgb=np.rint(color).astype(np.uint8), | |
| ) | |
| ) | |
| return boxes, document | |
| def _ray_box_depth( | |
| box: OrientedBoundingBox, | |
| rays_camera: np.ndarray, | |
| w2c: np.ndarray, | |
| near: float, | |
| ) -> np.ndarray: | |
| """Return camera-z at the first positive ray/OBB intersection.""" | |
| c2w = np.linalg.inv(w2c) | |
| camera_center_world = c2w[:3, 3] | |
| rotation_c2w = c2w[:3, :3] | |
| origin_local = box.rotation_world.T @ (camera_center_world - box.center_xyz) | |
| rays_world = rays_camera @ rotation_c2w.T | |
| rays_local = rays_world @ box.rotation_world | |
| parallel_outside = (np.abs(rays_local) < 1e-12) & ( | |
| np.abs(origin_local)[None, None, :] > box.half_size[None, None, :] | |
| ) | |
| safe_direction = np.where( | |
| np.abs(rays_local) < 1e-12, | |
| np.where(rays_local >= 0, 1e-12, -1e-12), | |
| rays_local, | |
| ) | |
| t_0 = (-box.half_size - origin_local) / safe_direction | |
| t_1 = (box.half_size - origin_local) / safe_direction | |
| t_near = np.max(np.minimum(t_0, t_1), axis=-1) | |
| t_far = np.min(np.maximum(t_0, t_1), axis=-1) | |
| first = np.where(t_near >= near, t_near, t_far) | |
| valid = ( | |
| (t_far >= np.maximum(t_near, near)) | |
| & (first >= near) | |
| & ~np.any(parallel_outside, axis=-1) | |
| ) | |
| return np.where(valid, first, np.inf) | |
| def _project_vertices( | |
| vertices_world: np.ndarray, | |
| intrinsics: np.ndarray, | |
| w2c: np.ndarray, | |
| ) -> Tuple[np.ndarray, np.ndarray]: | |
| vertices_camera = vertices_world @ w2c[:3, :3].T + w2c[:3, 3] | |
| valid = vertices_camera[:, 2] > 1e-6 | |
| normalized = vertices_camera / np.maximum(vertices_camera[:, 2:3], 1e-6) | |
| pixels = normalized @ intrinsics.T | |
| return pixels[:, :2], valid | |
| def render_bbox_conditions( | |
| boxes: Iterable[OrientedBoundingBox], | |
| intrinsics: np.ndarray, | |
| w2c: np.ndarray, | |
| height: int, | |
| width: int, | |
| near: float = 0.05, | |
| depth_far: float = 20.0, | |
| edge_width: int = 4, | |
| fill_alpha: float = 0.38, | |
| ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: | |
| """Render filled OBB silhouettes, 12 box edges, encoded depth, and raw depth.""" | |
| if near <= 0 or depth_far <= near: | |
| raise ValueError("Require 0 < near < depth_far.") | |
| rays = camera_rays(intrinsics, height, width) | |
| raw_depth = np.full((height, width), np.inf, dtype=np.float64) | |
| identity_rgb = np.zeros((height, width, 3), dtype=np.uint8) | |
| box_mask = np.zeros((height, width), dtype=np.uint8) | |
| box_list = list(boxes) | |
| for box in box_list: | |
| depth = _ray_box_depth(box, rays, w2c, near) | |
| replace = depth < raw_depth | |
| if np.any(replace): | |
| raw_depth[replace] = depth[replace] | |
| identity_rgb[replace] = np.rint( | |
| box.color_rgb.astype(np.float64) * fill_alpha | |
| ).astype(np.uint8) | |
| box_mask[replace] = 255 | |
| rectangle = (0, 0, width, height) | |
| for box in box_list: | |
| pixels, valid_vertices = _project_vertices(box.vertices_world, intrinsics, w2c) | |
| color = tuple(int(channel) for channel in box.color_rgb) | |
| for start_index, end_index in BOX_EDGES: | |
| if not (valid_vertices[start_index] and valid_vertices[end_index]): | |
| continue | |
| point_0 = tuple(np.rint(np.clip(pixels[start_index], -1e6, 1e6)).astype(int)) | |
| point_1 = tuple(np.rint(np.clip(pixels[end_index], -1e6, 1e6)).astype(int)) | |
| visible, clipped_0, clipped_1 = cv2.clipLine(rectangle, point_0, point_1) | |
| if visible: | |
| cv2.line(identity_rgb, clipped_0, clipped_1, color, edge_width, cv2.LINE_AA) | |
| cv2.line(box_mask, clipped_0, clipped_1, 255, edge_width, cv2.LINE_AA) | |
| valid_depth = np.isfinite(raw_depth) | |
| raw_depth_output = raw_depth.astype(np.float32) | |
| raw_depth_output[~valid_depth] = 0.0 | |
| encoded = np.zeros((height, width), dtype=np.float64) | |
| encoded[valid_depth] = 1.0 - np.clip( | |
| (raw_depth[valid_depth] - near) / (depth_far - near), 0.0, 1.0 | |
| ) | |
| encoded_uint8 = np.rint(encoded * 255.0).astype(np.uint8) | |
| depth_rgb = np.repeat(encoded_uint8[..., None], 3, axis=-1) | |
| return identity_rgb, depth_rgb, box_mask, raw_depth_output | |