| | 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 |
| |
|
