Spaces:
Runtime error
Runtime error
| # Copyright (C) 2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved. | |
| # | |
| # This work is made available under the Nvidia Source Code License-NC. | |
| # To view a copy of this license, check out LICENSE.md | |
| import numpy as np | |
| import torch | |
| class EvalCameraController: | |
| def __init__(self, voxel, maxstep=128, pattern=0, cam_ang=73, smooth_decay_multiplier=1.0): | |
| self.voxel = voxel | |
| self.maxstep = maxstep | |
| self.camera_poses = [] # ori, dir, up, f | |
| circle = torch.linspace(0, 2*np.pi, steps=maxstep) | |
| size = min(voxel.voxel_t.size(1), voxel.voxel_t.size(2)) / 2 | |
| # Shrink the circle a bit. | |
| shift = size * 0.2 | |
| size = size * 0.8 | |
| if pattern == 0: | |
| height_history = [] | |
| # Calculate smooth height. | |
| for i in range(maxstep): | |
| farpoint = torch.tensor([ | |
| 70, | |
| torch.sin(circle[i])*size + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i])*size + voxel.voxel_t.size(2)/2 + shift]) | |
| height_history.append(self._get_height(farpoint[1], farpoint[2], farpoint[0])) | |
| # Filtfilt | |
| height_history = self.filtfilt(height_history, decay=0.2*smooth_decay_multiplier) | |
| for i in range(maxstep): | |
| farpoint = torch.tensor([ | |
| 70, | |
| torch.sin(circle[i])*size + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i])*size + voxel.voxel_t.size(2)/2 + shift]) | |
| farpoint[0] = height_history[i] | |
| nearpoint = torch.tensor([ | |
| 60, | |
| torch.sin(circle[i]+0.5*np.pi)*size*0.5 + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i]+0.5*np.pi)*size*0.5 + voxel.voxel_t.size(2)/2 + shift]) | |
| cam_ori = self.voxel.world2local(farpoint) | |
| cam_dir = self.voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = self.voxel.world2local(torch.tensor([1, 0, 0], dtype=torch.float32), is_vec=True) | |
| cam_f = 0.5/np.tan(np.deg2rad(cam_ang/2)) # about 24mm fov | |
| self.camera_poses.append((cam_ori, cam_dir, cam_up, cam_f)) | |
| elif pattern == 1: | |
| zoom = torch.linspace(1.0, 0.25, steps=maxstep) | |
| height_history = [] | |
| for i in range(maxstep): | |
| farpoint = torch.tensor([ | |
| 90, | |
| torch.sin(circle[i])*size + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i])*size + voxel.voxel_t.size(2)/2 + shift]) | |
| height_history.append(self._get_height(farpoint[1], farpoint[2], farpoint[0])) | |
| height_history = self.filtfilt(height_history, decay=0.2*smooth_decay_multiplier) | |
| for i in range(maxstep): | |
| farpoint = torch.tensor([ | |
| 90, | |
| torch.sin(circle[i])*size + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i])*size + voxel.voxel_t.size(2)/2 + shift]) | |
| farpoint[0] = height_history[i] | |
| nearpoint = torch.tensor([ | |
| 60, | |
| torch.sin(circle[i]-0.3*np.pi)*size*0.3 + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i]-0.3*np.pi)*size*0.3 + voxel.voxel_t.size(2)/2 + shift]) | |
| cam_ori = self.voxel.world2local(farpoint) | |
| cam_dir = self.voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = self.voxel.world2local(torch.tensor([1, 0, 0], dtype=torch.float32), is_vec=True) | |
| cam_f = 0.5/np.tan(np.deg2rad(cam_ang/2)*zoom[i]) # about 24mm fov | |
| self.camera_poses.append((cam_ori, cam_dir, cam_up, cam_f)) | |
| elif pattern == 2: | |
| move = torch.linspace(1.0, 0.2, steps=maxstep) | |
| height_history = [] | |
| for i in range(maxstep): | |
| farpoint = torch.tensor([ | |
| 90, | |
| torch.sin(circle[i])*size*move[i] + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i])*size*move[i] + voxel.voxel_t.size(2)/2 + shift]) | |
| height_history.append(self._get_height(farpoint[1], farpoint[2], farpoint[0])) | |
| height_history = self.filtfilt(height_history, decay=0.2*smooth_decay_multiplier) | |
| for i in range(maxstep): | |
| farpoint = torch.tensor([ | |
| 90, | |
| torch.sin(circle[i])*size*move[i] + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i])*size*move[i] + voxel.voxel_t.size(2)/2 + shift]) | |
| farpoint[0] = height_history[i] | |
| nearpoint = torch.tensor([ | |
| 60, | |
| torch.sin(circle[i]+0.5*np.pi)*size*0.3*move[i] + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i]+0.5*np.pi)*size*0.3*move[i] + voxel.voxel_t.size(2)/2 + shift]) | |
| cam_ori = self.voxel.world2local(farpoint) | |
| cam_dir = self.voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = self.voxel.world2local(torch.tensor([1, 0, 0], dtype=torch.float32), is_vec=True) | |
| cam_f = 0.5/np.tan(np.deg2rad(cam_ang/2)) # about 24mm fov | |
| self.camera_poses.append((cam_ori, cam_dir, cam_up, cam_f)) | |
| elif pattern == 3: | |
| move = torch.linspace(0.75, 0.2, steps=maxstep) | |
| height_history = [] | |
| for i in range(maxstep): | |
| farpoint = torch.tensor([ | |
| 70, | |
| torch.sin(-circle[i])*size*move[i] + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(-circle[i])*size*move[i] + voxel.voxel_t.size(2)/2 + shift]) | |
| height_history.append(self._get_height(farpoint[1], farpoint[2], farpoint[0])) | |
| height_history = self.filtfilt(height_history, decay=0.2*smooth_decay_multiplier) | |
| for i in range(maxstep): | |
| farpoint = torch.tensor([ | |
| 70, | |
| torch.sin(-circle[i])*size*move[i] + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(-circle[i])*size*move[i] + voxel.voxel_t.size(2)/2 + shift]) | |
| farpoint[0] = height_history[i] | |
| nearpoint = torch.tensor([ | |
| 60, | |
| torch.sin(-circle[i]-0.4*np.pi)*size*0.9*move[i] + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(-circle[i]-0.4*np.pi)*size*0.9*move[i] + voxel.voxel_t.size(2)/2 + shift]) | |
| cam_ori = self.voxel.world2local(farpoint) | |
| cam_dir = self.voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = self.voxel.world2local(torch.tensor([1, 0, 0], dtype=torch.float32), is_vec=True) | |
| cam_f = 0.5/np.tan(np.deg2rad(cam_ang/2)) # about 24mm fov | |
| self.camera_poses.append((cam_ori, cam_dir, cam_up, cam_f)) | |
| elif pattern == 4: | |
| move = torch.linspace(1.0, 0.5, steps=maxstep) | |
| height_history = [] | |
| for i in range(maxstep): | |
| farpoint = torch.tensor([ | |
| 90, | |
| torch.sin(circle[i])*size*move[i] + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i])*size*move[i] + voxel.voxel_t.size(2)/2 + shift]) | |
| height_history.append(self._get_height(farpoint[1], farpoint[2], farpoint[0])) | |
| height_history = self.filtfilt(height_history, decay=0.2*smooth_decay_multiplier) | |
| for i in range(maxstep): | |
| farpoint = torch.tensor([ | |
| 90, | |
| torch.sin(circle[i])*size*move[i] + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i])*size*move[i] + voxel.voxel_t.size(2)/2 + shift]) | |
| farpoint[0] = height_history[i] | |
| nearpoint = torch.tensor([ | |
| 60, | |
| torch.sin(circle[i]+0.5*np.pi)*size*0.3*move[i] + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i]+0.5*np.pi)*size*0.3*move[i] + voxel.voxel_t.size(2)/2 + shift]) | |
| cam_ori = self.voxel.world2local(farpoint) | |
| cam_dir = self.voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = self.voxel.world2local(torch.tensor([1, 0, 0], dtype=torch.float32), is_vec=True) | |
| cam_f = 0.5/np.tan(np.deg2rad(cam_ang/2)) # about 24mm fov | |
| self.camera_poses.append((cam_ori, cam_dir, cam_up, cam_f)) | |
| # look outward | |
| elif pattern == 5: | |
| move = torch.linspace(1.0, 0.5, steps=maxstep) | |
| height_history = [] | |
| for i in range(maxstep): | |
| nearpoint = torch.tensor([ | |
| 60, | |
| torch.sin(circle[i]+0.5*np.pi)*size*0.3*move[i] + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i]+0.5*np.pi)*size*0.3*move[i] + voxel.voxel_t.size(2)/2 + shift]) | |
| height_history.append(self._get_height(nearpoint[1], nearpoint[2], nearpoint[0])) | |
| height_history = self.filtfilt(height_history, decay=0.2*smooth_decay_multiplier) | |
| for i in range(maxstep): | |
| nearpoint = torch.tensor([ | |
| 60, | |
| torch.sin(circle[i]+0.5*np.pi)*size*0.3*move[i] + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i]+0.5*np.pi)*size*0.3*move[i] + voxel.voxel_t.size(2)/2 + shift]) | |
| nearpoint[0] = height_history[i] | |
| farpoint = torch.tensor([ | |
| 60, | |
| torch.sin(circle[i])*size*move[i] + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i])*size*move[i] + voxel.voxel_t.size(2)/2 + shift]) | |
| cam_ori = self.voxel.world2local(nearpoint) | |
| cam_dir = self.voxel.world2local(farpoint - nearpoint, is_vec=True) | |
| cam_up = self.voxel.world2local(torch.tensor([1, 0, 0], dtype=torch.float32), is_vec=True) | |
| cam_f = 0.5/np.tan(np.deg2rad(cam_ang/2)) # about 24mm fov | |
| self.camera_poses.append((cam_ori, cam_dir, cam_up, cam_f)) | |
| # Rise | |
| elif pattern == 6: | |
| shift = 0 | |
| lift = torch.linspace(0.0, 200.0, steps=maxstep) | |
| zoom = torch.linspace(0.8, 1.6, steps=maxstep) | |
| for i in range(maxstep): | |
| farpoint = torch.tensor([ | |
| 80+lift[i], | |
| torch.sin(circle[i]/4)*size*0.2 + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i]/4)*size*0.2 + voxel.voxel_t.size(2)/2 + shift]) | |
| farpoint[0] = self._get_height(farpoint[1], farpoint[2], farpoint[0]) | |
| nearpoint = torch.tensor([ | |
| 65, | |
| torch.sin(circle[i]/4+0.5*np.pi)*size*0.1 + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i]/4+0.5*np.pi)*size*0.1 + voxel.voxel_t.size(2)/2 + shift]) | |
| cam_ori = self.voxel.world2local(farpoint) | |
| cam_dir = self.voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = self.voxel.world2local(torch.tensor([1, 0, 0], dtype=torch.float32), is_vec=True) | |
| cam_f = 0.5/np.tan(np.deg2rad(73/2)*zoom[i]) # about 24mm fov | |
| self.camera_poses.append((cam_ori, cam_dir, cam_up, cam_f)) | |
| # 45deg | |
| elif pattern == 7: | |
| rad = torch.tensor([np.deg2rad(45).astype(np.float32)]) | |
| size = 1536 | |
| for i in range(maxstep): | |
| farpoint = torch.tensor([ | |
| 61+size, | |
| torch.sin(rad)*size + voxel.voxel_t.size(1)/2, | |
| torch.cos(rad)*size + voxel.voxel_t.size(2)/2]) | |
| nearpoint = torch.tensor([ | |
| 61, | |
| voxel.voxel_t.size(1)/2, | |
| voxel.voxel_t.size(2)/2]) | |
| cam_ori = self.voxel.world2local(farpoint) | |
| cam_dir = self.voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = self.voxel.world2local(torch.tensor([1, 0, 0], dtype=torch.float32), is_vec=True) | |
| cam_f = 0.5/np.tan(np.deg2rad(19.5/2)) # about 50mm fov | |
| self.camera_poses.append((cam_ori, cam_dir, cam_up, cam_f)) | |
| def _get_height(self, loc0, loc1, minheight): | |
| loc0 = int(loc0) | |
| loc1 = int(loc1) | |
| height = minheight | |
| for dx in range(-3, 4): | |
| for dy in range(-3, 4): | |
| if (loc0+dx) < 0 or (loc0+dx) >= self.voxel.heightmap.shape[0] or (loc1+dy) < 0 or \ | |
| (loc1+dy) >= self.voxel.heightmap.shape[1]: | |
| height = max(height, minheight) | |
| else: | |
| height = max(height, self.voxel.heightmap[loc0+dx, loc1+dy] + 2) | |
| return height | |
| def filtfilt(self, height_history, decay=0.2): | |
| # Filtfilt | |
| height_history2 = [] | |
| maxstep = len(height_history) | |
| prev_height = height_history[0] | |
| for i in range(maxstep): | |
| prev_height = prev_height - decay | |
| if prev_height < height_history[i]: | |
| prev_height = height_history[i] | |
| height_history2.append(prev_height) | |
| prev_height = height_history[-1] | |
| for i in range(maxstep-1, -1, -1): | |
| prev_height = prev_height - decay | |
| if prev_height < height_history[i]: | |
| prev_height = height_history[i] | |
| height_history2[i] = max(prev_height, height_history2[i]) | |
| return height_history2 | |
| def __len__(self): | |
| return len(self.camera_poses) | |
| def __getitem__(self, idx): | |
| return self.camera_poses[idx] | |
| class TourCameraController: | |
| def __init__(self, voxel, maxstep=128): | |
| self.voxel = voxel | |
| self.maxstep = maxstep | |
| self.camera_poses = [] # ori, dir, up, f | |
| circle = torch.linspace(0, 2*np.pi, steps=maxstep//4) | |
| size = min(voxel.voxel_t.size(1), voxel.voxel_t.size(2)) / 2 | |
| # Shrink the circle a bit | |
| shift = size * 0.2 | |
| size = size * 0.8 | |
| for i in range(maxstep//4): | |
| farpoint = torch.tensor([ | |
| 70, | |
| torch.sin(circle[i])*size + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i])*size + voxel.voxel_t.size(2)/2 + shift]) | |
| farpoint[0] = self._get_height(farpoint[1], farpoint[2], farpoint[0]) | |
| nearpoint = torch.tensor([ | |
| 60, | |
| torch.sin(circle[i]+0.5*np.pi)*size*0.5 + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i]+0.5*np.pi)*size*0.5 + voxel.voxel_t.size(2)/2 + shift]) | |
| cam_ori = self.voxel.world2local(farpoint) | |
| cam_dir = self.voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = self.voxel.world2local(torch.tensor([1, 0, 0], dtype=torch.float32), is_vec=True) | |
| cam_f = 0.5/np.tan(np.deg2rad(73/2)) # about 24mm fov | |
| self.camera_poses.append((cam_ori, cam_dir, cam_up, cam_f)) | |
| zoom = torch.linspace(1.0, 0.25, steps=maxstep//4) | |
| for i in range(maxstep//4): | |
| farpoint = torch.tensor([ | |
| 90, | |
| torch.sin(circle[i])*size + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i])*size + voxel.voxel_t.size(2)/2 + shift]) | |
| farpoint[0] = self._get_height(farpoint[1], farpoint[2], farpoint[0]) | |
| nearpoint = torch.tensor([ | |
| 60, | |
| torch.sin(circle[i]-0.3*np.pi)*size*0.3 + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i]-0.3*np.pi)*size*0.3 + voxel.voxel_t.size(2)/2 + shift]) | |
| cam_ori = self.voxel.world2local(farpoint) | |
| cam_dir = self.voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = self.voxel.world2local(torch.tensor([1, 0, 0], dtype=torch.float32), is_vec=True) | |
| cam_f = 0.5/np.tan(np.deg2rad(73/2)*zoom[i]) # about 24mm fov | |
| self.camera_poses.append((cam_ori, cam_dir, cam_up, cam_f)) | |
| move = torch.linspace(1.0, 0.2, steps=maxstep//4) | |
| for i in range(maxstep//4): | |
| farpoint = torch.tensor([ | |
| 90, | |
| torch.sin(circle[i])*size*move[i] + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i])*size*move[i] + voxel.voxel_t.size(2)/2 + shift]) | |
| farpoint[0] = self._get_height(farpoint[1], farpoint[2], farpoint[0]) | |
| nearpoint = torch.tensor([ | |
| 60, | |
| torch.sin(circle[i]+0.5*np.pi)*size*0.3*move[i] + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i]+0.5*np.pi)*size*0.3*move[i] + voxel.voxel_t.size(2)/2 + shift]) | |
| cam_ori = self.voxel.world2local(farpoint) | |
| cam_dir = self.voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = self.voxel.world2local(torch.tensor([1, 0, 0], dtype=torch.float32), is_vec=True) | |
| cam_f = 0.5/np.tan(np.deg2rad(73/2)) # about 24mm fov | |
| self.camera_poses.append((cam_ori, cam_dir, cam_up, cam_f)) | |
| lift = torch.linspace(0.0, 200.0, steps=maxstep//4) | |
| zoom = torch.linspace(0.6, 1.2, steps=maxstep//4) | |
| for i in range(maxstep//4): | |
| farpoint = torch.tensor([ | |
| 80+lift[i], | |
| torch.sin(circle[i])*size*0.2 + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i])*size*0.2 + voxel.voxel_t.size(2)/2 + shift]) | |
| farpoint[0] = self._get_height(farpoint[1], farpoint[2], farpoint[0]) | |
| nearpoint = torch.tensor([ | |
| 60, | |
| torch.sin(circle[i]+0.5*np.pi)*size*0.1 + voxel.voxel_t.size(1)/2 + shift, | |
| torch.cos(circle[i]+0.5*np.pi)*size*0.1 + voxel.voxel_t.size(2)/2 + shift]) | |
| cam_ori = self.voxel.world2local(farpoint) | |
| cam_dir = self.voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = self.voxel.world2local(torch.tensor([1, 0, 0], dtype=torch.float32), is_vec=True) | |
| cam_f = 0.5/np.tan(np.deg2rad(73/2)*zoom[i]) # about 24mm fov | |
| self.camera_poses.append((cam_ori, cam_dir, cam_up, cam_f)) | |
| def _get_height(self, loc0, loc1, minheight): | |
| loc0 = int(loc0) | |
| loc1 = int(loc1) | |
| height = minheight | |
| for dx in range(-3, 4): | |
| for dy in range(-3, 4): | |
| if (loc0+dx) < 0 or (loc0+dx) >= self.voxel.heightmap.shape[0] or (loc1+dy) < 0 or \ | |
| (loc1+dy) >= self.voxel.heightmap.shape[1]: | |
| height = max(height, minheight) | |
| else: | |
| height = max(height, self.voxel.heightmap[loc0+dx, loc1+dy] + 2) | |
| return height | |
| def __len__(self): | |
| return len(self.camera_poses) | |
| def __getitem__(self, idx): | |
| return self.camera_poses[idx] | |
| def rand_camera_pose_birdseye(voxel, border=128): | |
| r"""Generating random camera pose in the upper hemisphere, in the format of origin-direction-up | |
| Assuming [Y X Z] coordinate. Y is negative gravity direction. | |
| The camera pose is converted into the voxel coordinate system so that it can be used directly for rendering | |
| 1. Uniformly sample a point on the upper hemisphere of a unit sphere, as cam_ori. | |
| 2. Set cam_dir to be from cam_ori to the origin | |
| 3. cam_up is always pointing towards sky | |
| 4. move cam_ori to random place according to voxel size | |
| """ | |
| cam_dir = torch.randn(3, dtype=torch.float32) | |
| cam_dir = cam_dir / torch.sqrt(torch.sum(cam_dir*cam_dir)) | |
| cam_dir[0] = -torch.abs(cam_dir[0]) | |
| cam_up = torch.tensor([1, 0, 0], dtype=torch.float32) | |
| # generate camera lookat target | |
| r = np.random.rand(2) | |
| r[0] *= voxel.voxel_t.size(1)-border-border | |
| r[1] *= voxel.voxel_t.size(2)-border-border | |
| r = r + border | |
| y = voxel.heightmap[int(r[0]+0.5), int(r[1]+0.5)] + (np.random.rand(1)-0.5) * 5 | |
| cam_target = torch.tensor([y, r[0], r[1]], dtype=torch.float32) | |
| cam_ori = cam_target - cam_dir * (np.random.rand(1).item() * 100) | |
| cam_ori[0] = max(voxel.heightmap[int(cam_ori[1]+0.5), int(cam_ori[2]+0.5)]+2, cam_ori[0]) | |
| # Translate to voxel coordinate | |
| cam_ori = voxel.world2local(cam_ori) | |
| cam_dir = voxel.world2local(cam_dir, is_vec=True) | |
| cam_up = voxel.world2local(cam_up, is_vec=True) | |
| return cam_ori, cam_dir, cam_up | |
| def get_neighbor_height(heightmap, loc0, loc1, minheight, neighbor_size=7): | |
| loc0 = int(loc0) | |
| loc1 = int(loc1) | |
| height = 0 | |
| for dx in range(-neighbor_size//2, neighbor_size//2+1): | |
| for dy in range(-neighbor_size//2, neighbor_size//2+1): | |
| if (loc0+dx) < 0 or (loc0+dx) >= heightmap.shape[0] or (loc1+dy) < 0 or (loc1+dy) >= heightmap.shape[1]: | |
| height = max(height, minheight) | |
| else: | |
| height = max(minheight, heightmap[loc0+dx, loc1+dy] + 2) | |
| return height | |
| def rand_camera_pose_firstperson(voxel, border=128): | |
| r"""Generating random camera pose in the upper hemisphere, in the format of origin-direction-up | |
| """ | |
| r = np.random.rand(5) | |
| r[0] *= voxel.voxel_t.size(1)-border-border | |
| r[1] *= voxel.voxel_t.size(2)-border-border | |
| r[0] = r[0] + border | |
| r[1] = r[1] + border | |
| y = get_neighbor_height(voxel.heightmap, r[0], r[1], 0) + np.random.rand(1) * 15 | |
| cam_ori = torch.tensor([y, r[0], r[1]], dtype=torch.float32) | |
| rand_ang_h = r[2] * 2 * np.pi | |
| cam_target = torch.tensor([0, cam_ori[1]+np.sin(rand_ang_h)*border*r[4], cam_ori[2] + | |
| np.cos(rand_ang_h)*border*r[4]], dtype=torch.float32) | |
| cam_target[0] = get_neighbor_height(voxel.heightmap, cam_target[1], | |
| cam_target[2], 0, neighbor_size=1) - 2 + r[3] * 10 | |
| cam_dir = cam_target - cam_ori | |
| cam_up = torch.tensor([1, 0, 0], dtype=torch.float32) | |
| cam_ori = voxel.world2local(cam_ori) | |
| cam_dir = voxel.world2local(cam_dir, is_vec=True) | |
| cam_up = voxel.world2local(cam_up, is_vec=True) | |
| return cam_ori, cam_dir, cam_up | |
| def rand_camera_pose_thridperson(voxel, border=96): | |
| r = torch.rand(2) | |
| r[0] *= voxel.voxel_t.size(1) | |
| r[1] *= voxel.voxel_t.size(2) | |
| rand_height = 60 + torch.rand(1) * 40 | |
| rand_height = get_neighbor_height(voxel.heightmap, r[0], r[1], rand_height, neighbor_size=5) | |
| farpoint = torch.tensor([rand_height, r[0], r[1]], dtype=torch.float32) | |
| r = torch.rand(2) | |
| r[0] *= voxel.voxel_t.size(1) - border - border | |
| r[1] *= voxel.voxel_t.size(2) - border - border | |
| r[0] = r[0] + border | |
| r[1] = r[1] + border | |
| rand_height = get_neighbor_height(voxel.heightmap, r[0], r[1], 65, neighbor_size=1) - 5 | |
| nearpoint = torch.tensor([rand_height, r[0], r[1]], dtype=torch.float32) | |
| cam_ori = voxel.world2local(farpoint) | |
| cam_dir = voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = voxel.world2local(torch.tensor([1, 0, 0], dtype=torch.float32), is_vec=True) | |
| return cam_ori, cam_dir, cam_up | |
| def rand_camera_pose_thridperson2(voxel, border=48): | |
| r = torch.rand(2) | |
| r[0] *= voxel.voxel_t.size(1) - border - border | |
| r[1] *= voxel.voxel_t.size(2) - border - border | |
| r[0] = r[0] + border | |
| r[1] = r[1] + border | |
| rand_height = 60 + torch.rand(1) * 40 | |
| rand_height = get_neighbor_height(voxel.heightmap, r[0], r[1], rand_height, neighbor_size=5) | |
| farpoint = torch.tensor([rand_height, r[0], r[1]], dtype=torch.float32) | |
| r = torch.rand(2) | |
| r[0] *= voxel.voxel_t.size(1) - border - border | |
| r[1] *= voxel.voxel_t.size(2) - border - border | |
| r[0] = r[0] + border | |
| r[1] = r[1] + border | |
| rand_height = get_neighbor_height(voxel.heightmap, r[0], r[1], 65, neighbor_size=1) - 5 | |
| nearpoint = torch.tensor([rand_height, r[0], r[1]], dtype=torch.float32) | |
| # Random Up vector (tilt a little bit) | |
| # up = torch.randn(3) * 0.05 # cutoff +-0.1, Tan(10deg) = 0.176 | |
| up = torch.randn(3) * 0.02 | |
| up[0] = 1.0 | |
| up = up / up.norm(p=2) | |
| cam_ori = voxel.world2local(farpoint) | |
| cam_dir = voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = voxel.world2local(up, is_vec=True) | |
| return cam_ori, cam_dir, cam_up | |
| def rand_camera_pose_thridperson3(voxel, border=64): | |
| r"""Attempting to solve the camera too close to wall problem and the lack of aerial poses.""" | |
| r = torch.rand(2) | |
| r[0] *= voxel.voxel_t.size(1) - border - border | |
| r[1] *= voxel.voxel_t.size(2) - border - border | |
| r[0] = r[0] + border | |
| r[1] = r[1] + border | |
| rand_height = 60 + torch.rand(1) * 40 | |
| if torch.rand(1) > 0.8: | |
| rand_height = 60 + torch.rand(1) * 60 | |
| rand_height = get_neighbor_height(voxel.heightmap, r[0], r[1], rand_height, neighbor_size=7) | |
| farpoint = torch.tensor([rand_height, r[0], r[1]], dtype=torch.float32) | |
| r = torch.rand(2) | |
| r[0] *= voxel.voxel_t.size(1) - border - border | |
| r[1] *= voxel.voxel_t.size(2) - border - border | |
| r[0] = r[0] + border | |
| r[1] = r[1] + border | |
| rand_height = get_neighbor_height(voxel.heightmap, r[0], r[1], 65, neighbor_size=3) - 5 | |
| nearpoint = torch.tensor([rand_height, r[0], r[1]], dtype=torch.float32) | |
| # Random Up vector (tilt a little bit) | |
| # up = torch.randn(3) * 0.05 # cutoff +-0.1, Tan(10deg) = 0.176 | |
| up = torch.randn(3) * 0.02 | |
| up[0] = 1.0 | |
| up = up / up.norm(p=2) | |
| # print(up) | |
| cam_ori = voxel.world2local(farpoint) | |
| cam_dir = voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = voxel.world2local(up, is_vec=True) | |
| return cam_ori, cam_dir, cam_up | |
| def rand_camera_pose_tour(voxel): | |
| size = min(voxel.voxel_t.size(1), voxel.voxel_t.size(2)) / 2 | |
| center = [voxel.voxel_t.size(1)/2, voxel.voxel_t.size(2)/2] | |
| rnd = torch.rand(8) | |
| rnd_deg = torch.rand(1) * 2 * np.pi | |
| far_radius = rnd[0]*0.8+0.2 | |
| far_height = rnd[1]*30 + 60 | |
| farpoint = torch.tensor([ | |
| far_height, | |
| torch.sin(rnd_deg)*size*far_radius + center[0], | |
| torch.cos(rnd_deg)*size*far_radius + center[1]]) | |
| farpoint[0] = get_neighbor_height(voxel.heightmap, farpoint[1], farpoint[2], farpoint[0], neighbor_size=7) | |
| near_radius = far_radius * rnd[2] | |
| near_shift_rad = np.pi*(rnd[3]-0.5) | |
| near_height = 60 + rnd[4] * 10 | |
| nearpoint = torch.tensor([ | |
| near_height, | |
| torch.sin(rnd_deg+near_shift_rad)*size*near_radius + center[0], | |
| torch.cos(rnd_deg+near_shift_rad)*size*near_radius + center[1]]) | |
| # Random Up vector (tilt a little bit) | |
| # up = torch.randn(3) * 0.05 # cutoff +-0.1, Tan(10deg) = 0.176 | |
| up = torch.randn(3) * 0.02 | |
| up[0] = 1.0 | |
| up = up / up.norm(p=2) | |
| cam_ori = voxel.world2local(farpoint) | |
| cam_dir = voxel.world2local(nearpoint - farpoint, is_vec=True) | |
| cam_up = voxel.world2local(up, is_vec=True) | |
| cam_f = 0.5/np.tan(np.deg2rad(73/2)*(rnd[5]*0.75+0.25)) # about 24mm fov | |
| return cam_ori, cam_dir, cam_up, cam_f | |
| # Look from center to outward | |
| def rand_camera_pose_insideout(voxel): | |
| size = min(voxel.voxel_t.size(1), voxel.voxel_t.size(2)) / 2 | |
| center = [voxel.voxel_t.size(1)/2, voxel.voxel_t.size(2)/2] | |
| rnd = torch.rand(8) | |
| rnd_deg = torch.rand(1) * 2 * np.pi | |
| far_radius = rnd[0]*0.8+0.2 | |
| far_height = rnd[1]*10 + 60 | |
| farpoint = torch.tensor([ | |
| far_height, | |
| torch.sin(rnd_deg)*size*far_radius + center[0], | |
| torch.cos(rnd_deg)*size*far_radius + center[1]]) | |
| near_radius = far_radius * rnd[2] | |
| near_shift_rad = np.pi*(rnd[3]-0.5) | |
| near_height = 60 + rnd[4] * 30 | |
| nearpoint = torch.tensor([ | |
| near_height, | |
| torch.sin(rnd_deg+near_shift_rad)*size*near_radius + center[0], | |
| torch.cos(rnd_deg+near_shift_rad)*size*near_radius + center[1]]) | |
| nearpoint[0] = get_neighbor_height(voxel.heightmap, nearpoint[1], nearpoint[2], nearpoint[0], neighbor_size=7) | |
| # Random Up vector (tilt a little bit) | |
| # up = torch.randn(3) * 0.05 # cutoff +-0.1, Tan(10deg) = 0.176 | |
| up = torch.randn(3) * 0.02 | |
| up[0] = 1.0 | |
| up = up / up.norm(p=2) | |
| cam_ori = voxel.world2local(nearpoint) | |
| cam_dir = voxel.world2local(farpoint-nearpoint, is_vec=True) | |
| cam_up = voxel.world2local(up, is_vec=True) | |
| cam_f = 0.5/np.tan(np.deg2rad(73/2)*(rnd[5]*0.75+0.25)) # about 24mm fov | |
| return cam_ori, cam_dir, cam_up, cam_f | |