Spaces:
Running
Running
| # | |
| # Copyright (C) 2023, Inria | |
| # GRAPHDECO research group, https://team.inria.fr/graphdeco | |
| # All rights reserved. | |
| # | |
| # This software is free for non-commercial, research and evaluation use | |
| # under the terms of the LICENSE.md file. | |
| # | |
| # For inquiries contact [email protected] | |
| # | |
| import sys | |
| import numpy as np | |
| from field_construction.scene.cameras import Camera | |
| from field_construction.utils.graphics_utils import fov2focal | |
| WARNED = False | |
| def loadCam(args, id, cam_info, resolution_scale): | |
| orig_w, orig_h = cam_info.width, cam_info.height | |
| if args.resolution in [1, 2, 4, 8]: | |
| resolution = round(orig_w/(resolution_scale * args.resolution)), round(orig_h/(resolution_scale * args.resolution)) | |
| else: # should be a type that converts to float | |
| if args.resolution == -1: | |
| if orig_h > 1080: | |
| global WARNED | |
| if not WARNED: | |
| print("[ INFO ] Encountered quite large input images (>1080P), rescaling to 1080P.\n " | |
| "If this is not desired, please explicitly specify '--resolution/-r' as 1") | |
| WARNED = True | |
| global_down = orig_h / 1080 | |
| else: | |
| global_down = 1 | |
| else: | |
| global_down = orig_w / args.resolution | |
| scale = float(global_down) * float(resolution_scale) | |
| resolution = (int(orig_w / scale), int(orig_h / scale)) | |
| sys.stdout.write('\r') | |
| sys.stdout.write("load camera {}".format(id)) | |
| sys.stdout.write('\r') | |
| sys.stdout.flush() | |
| return Camera(colmap_id=cam_info.uid, R=cam_info.R, T=cam_info.T, | |
| FoVx=cam_info.FovX, FoVy=cam_info.FovY, | |
| image_width=resolution[0], image_height=resolution[1], | |
| image_path=cam_info.image_path, | |
| image_name=cam_info.image_name, uid=cam_info.global_id, | |
| preload_img=args.preload_img, | |
| ncc_scale=args.ncc_scale, | |
| data_device=args.data_device) | |
| def cameraList_from_camInfos(cam_infos, resolution_scale, args): | |
| camera_list = [] | |
| for id, c in enumerate(cam_infos): | |
| camera_list.append(loadCam(args, id, c, resolution_scale)) | |
| return camera_list | |
| def camera_to_JSON(id, camera : Camera): | |
| Rt = np.zeros((4, 4)) | |
| Rt[:3, :3] = camera.R.transpose() | |
| Rt[:3, 3] = camera.T | |
| Rt[3, 3] = 1.0 | |
| W2C = np.linalg.inv(Rt) | |
| pos = W2C[:3, 3] | |
| rot = W2C[:3, :3] | |
| serializable_array_2d = [x.tolist() for x in rot] | |
| camera_entry = { | |
| 'id' : id, | |
| 'img_name' : camera.image_name, | |
| 'width' : camera.width, | |
| 'height' : camera.height, | |
| 'position': pos.tolist(), | |
| 'rotation': serializable_array_2d, | |
| 'fy' : fov2focal(camera.FovY, camera.height), | |
| 'fx' : fov2focal(camera.FovX, camera.width) | |
| } | |
| return camera_entry | |
| def gen_virtul_cam(cam, trans_noise=1.0, deg_noise=15.0, device="cuda"): | |
| Rt = np.zeros((4, 4)) | |
| Rt[:3, :3] = cam.R.transpose() | |
| Rt[:3, 3] = cam.T | |
| Rt[3, 3] = 1.0 | |
| C2W = np.linalg.inv(Rt) | |
| translation_perturbation = np.random.uniform(-trans_noise, trans_noise, 3) | |
| rotation_perturbation = np.random.uniform(-deg_noise, deg_noise, 3) | |
| rx, ry, rz = np.deg2rad(rotation_perturbation) | |
| Rx = np.array([[1, 0, 0], | |
| [0, np.cos(rx), -np.sin(rx)], | |
| [0, np.sin(rx), np.cos(rx)]]) | |
| Ry = np.array([[np.cos(ry), 0, np.sin(ry)], | |
| [0, 1, 0], | |
| [-np.sin(ry), 0, np.cos(ry)]]) | |
| Rz = np.array([[np.cos(rz), -np.sin(rz), 0], | |
| [np.sin(rz), np.cos(rz), 0], | |
| [0, 0, 1]]) | |
| R_perturbation = Rz @ Ry @ Rx | |
| C2W[:3, :3] = C2W[:3, :3] @ R_perturbation | |
| C2W[:3, 3] = C2W[:3, 3] + translation_perturbation | |
| Rt = np.linalg.inv(C2W) | |
| virtul_cam = Camera(100000, Rt[:3, :3].transpose(), Rt[:3, 3], cam.FoVx, cam.FoVy, | |
| cam.image_width, cam.image_height, | |
| cam.image_path, cam.image_name, 100000, | |
| trans=np.array([0.0, 0.0, 0.0]), scale=1.0, | |
| preload_img=False, data_device=device) | |
| return virtul_cam | |