| """ |
| Pyrender-based voxel visualization renderer. |
| |
| Builds colored cube meshes from voxel centers and renders with pyrender |
| using stored camera intrinsics/extrinsics. |
| """ |
|
|
| import colorsys |
|
|
| import numpy as np |
| import trimesh |
| import pyrender |
|
|
|
|
| def build_palette(names): |
| """Assign evenly-spaced HSV hues; returns dict[name] -> (R, G, B) uint8.""" |
| n = max(len(names), 1) |
| palette = {} |
| for i, name in enumerate(names): |
| hue = i / n |
| r, g, b = colorsys.hsv_to_rgb(hue, 200 / 255, 230 / 255) |
| palette[name] = (int(r * 255), int(g * 255), int(b * 255)) |
| return palette |
|
|
|
|
| def compute_intrinsics(intr): |
| """Convert Blender camera intrinsics dict to (fx, fy, cx, cy).""" |
| focal = intr["focal_length"] |
| sw, sh = intr["sensor_width"], intr["sensor_height"] |
| res_x, res_y = intr["resolution_x"], intr["resolution_y"] |
| fit = intr.get("sensor_fit", "AUTO") |
|
|
| if fit == "VERTICAL": |
| fpx = focal / sh * res_y |
| elif fit == "HORIZONTAL": |
| fpx = focal / sw * res_x |
| else: |
| fpx = focal / sw * res_x if res_x >= res_y else focal / sh * res_y |
|
|
| fx = fy = float(fpx) |
| cx, cy = res_x / 2.0, res_y / 2.0 |
| return fx, fy, cx, cy |
|
|
|
|
| def blender_cam_to_pyrender_pose(cam_extrinsics): |
| """ |
| Normalize Blender's camera-to-world 4x4 for pyrender. |
| Blender cameras use OpenGL convention (X right, Y up, -Z forward). |
| """ |
| cam_mat = np.array(cam_extrinsics, dtype=np.float64) |
| scale = np.linalg.norm(cam_mat[:3, 0]) |
| if abs(scale - 1.0) > 1e-6: |
| cam_mat[:3, :3] /= scale |
| return cam_mat |
|
|
|
|
| def build_voxel_mesh(centers_dict, voxel_sizes, palette): |
| """ |
| Create a single combined trimesh from per-object voxel centers. |
| Each object's cubes are sized by its voxel_size and colored by the palette. |
| """ |
| all_vertices = [] |
| all_faces = [] |
| all_colors = [] |
| vertex_offset = 0 |
|
|
| for name, centers in centers_dict.items(): |
| if centers.shape[0] == 0: |
| continue |
|
|
| voxel_size = voxel_sizes[name] |
| r, g, b = palette.get(name, (200, 200, 200)) |
|
|
| box = trimesh.creation.box(extents=[voxel_size] * 3) |
| n_verts_per_box = len(box.vertices) |
| n_faces_per_box = len(box.faces) |
| n_voxels = len(centers) |
|
|
| vertices = np.tile(box.vertices, (n_voxels, 1)) |
| vertices += np.repeat(centers.astype(np.float64), n_verts_per_box, axis=0) |
|
|
| faces = np.tile(box.faces, (n_voxels, 1)) |
| faces += np.repeat(np.arange(n_voxels) * n_verts_per_box, |
| n_faces_per_box).reshape(-1, 1) |
| faces += vertex_offset |
|
|
| rgba = np.full((n_voxels * n_verts_per_box, 4), 255, dtype=np.uint8) |
| rgba[:, 0], rgba[:, 1], rgba[:, 2] = r, g, b |
|
|
| all_vertices.append(vertices) |
| all_faces.append(faces) |
| all_colors.append(rgba) |
| vertex_offset += n_voxels * n_verts_per_box |
|
|
| if not all_vertices: |
| return None |
|
|
| return trimesh.Trimesh( |
| vertices=np.vstack(all_vertices), |
| faces=np.vstack(all_faces), |
| vertex_colors=np.vstack(all_colors), |
| process=False, |
| ) |
|
|
|
|
| def render_frame(mesh, fx, fy, cx, cy, pose, W, H, background=None): |
| """ |
| Render a single frame with pyrender offscreen. |
| Returns an RGB uint8 image (H, W, 3). |
| If background (RGB) is provided, composites voxels on top. |
| """ |
| if mesh is None: |
| if background is not None: |
| return background.copy() |
| return np.zeros((H, W, 3), dtype=np.uint8) |
|
|
| scene = pyrender.Scene(bg_color=[0, 0, 0, 0], ambient_light=[0.3, 0.3, 0.3]) |
| scene.add(pyrender.Mesh.from_trimesh(mesh, smooth=False)) |
|
|
| camera = pyrender.IntrinsicsCamera(fx=fx, fy=fy, cx=cx, cy=cy, |
| znear=0.05, zfar=1000.0) |
| scene.add(camera, pose=pose) |
|
|
| light = pyrender.DirectionalLight(color=[1.0, 1.0, 1.0], intensity=3.0) |
| scene.add(light, pose=pose) |
|
|
| r = pyrender.OffscreenRenderer(viewport_width=W, viewport_height=H) |
| color_rgb, depth = r.render(scene) |
| r.delete() |
|
|
| if background is not None: |
| out = background.copy() |
| mask = depth > 0 |
| out[mask] = color_rgb[mask] |
| return out |
|
|
| return color_rgb |
|
|
