| import numpy as np |
| import torch |
| import torch.nn.functional as F |
| from loguru import logger as guru |
| from nerfview import CameraState |
|
|
| from flow3d.scene_model import SceneModel |
| from flow3d.vis.utils import draw_tracks_2d_th, get_server |
| from flow3d.vis.viewer import DynamicViewer |
|
|
|
|
| class Renderer: |
| def __init__( |
| self, |
| model: SceneModel, |
| device: torch.device, |
| |
| work_dir: str, |
| port: int | None = None, |
| ): |
| self.device = device |
|
|
| self.model = model |
| self.num_frames = model.num_frames |
|
|
| self.work_dir = work_dir |
| self.global_step = 0 |
| self.epoch = 0 |
|
|
| self.viewer = None |
| if port is not None: |
| server = get_server(port=port) |
| self.viewer = DynamicViewer( |
| server, self.render_fn, model.num_frames, work_dir, mode="rendering" |
| ) |
|
|
| self.tracks_3d = self.model.compute_poses_fg( |
| |
| torch.arange(self.num_frames, device=self.device), |
| inds=torch.arange(10, device=self.device), |
| )[0] |
|
|
| @staticmethod |
| def init_from_checkpoint( |
| path: str, device: torch.device, *args, **kwargs |
| ) -> "Renderer": |
| guru.info(f"Loading checkpoint from {path}") |
| ckpt = torch.load(path) |
| state_dict = ckpt["model"] |
| model = SceneModel.init_from_state_dict(state_dict) |
| model = model.to(device) |
| renderer = Renderer(model, device, *args, **kwargs) |
| renderer.global_step = ckpt.get("global_step", 0) |
| renderer.epoch = ckpt.get("epoch", 0) |
| return renderer |
|
|
| @torch.inference_mode() |
| def render_fn(self, camera_state: CameraState, img_wh: tuple[int, int]): |
| if self.viewer is None: |
| return np.full((img_wh[1], img_wh[0], 3), 255, dtype=np.uint8) |
|
|
| W, H = img_wh |
|
|
| focal = 0.5 * H / np.tan(0.5 * camera_state.fov).item() |
| K = torch.tensor( |
| [[focal, 0.0, W / 2.0], [0.0, focal, H / 2.0], [0.0, 0.0, 1.0]], |
| device=self.device, |
| ) |
| w2c = torch.linalg.inv( |
| torch.from_numpy(camera_state.c2w.astype(np.float32)).to(self.device) |
| ) |
| t = ( |
| int(self.viewer._playback_guis[0].value) |
| if not self.viewer._canonical_checkbox.value |
| else None |
| ) |
| self.model.training = False |
| img = self.model.render(t, w2c[None], K[None], img_wh)["img"][0] |
| if not self.viewer._render_track_checkbox.value: |
| img = (img.cpu().numpy() * 255.0).astype(np.uint8) |
| else: |
| assert t is not None |
| tracks_3d = self.tracks_3d[:, max(0, t - 20) : max(1, t)] |
| tracks_2d = torch.einsum( |
| "ij,jk,nbk->nbi", K, w2c[:3], F.pad(tracks_3d, (0, 1), value=1.0) |
| ) |
| tracks_2d = tracks_2d[..., :2] / tracks_2d[..., 2:] |
| img = draw_tracks_2d_th(img, tracks_2d) |
| return img |
|
|
