Spaces:
Runtime error
Runtime error
| """ utils | |
| """ | |
| import os | |
| import torch | |
| import numpy as np | |
| def load_checkpoint(fpath, model): | |
| print('loading checkpoint... {}'.format(fpath)) | |
| ckpt = torch.load(fpath, map_location='cpu')['model'] | |
| load_dict = {} | |
| for k, v in ckpt.items(): | |
| if k.startswith('module.'): | |
| k_ = k.replace('module.', '') | |
| load_dict[k_] = v | |
| else: | |
| load_dict[k] = v | |
| model.load_state_dict(load_dict) | |
| print('loading checkpoint... / done') | |
| return model | |
| def compute_normal_error(pred_norm, gt_norm): | |
| pred_error = torch.cosine_similarity(pred_norm, gt_norm, dim=1) | |
| pred_error = torch.clamp(pred_error, min=-1.0, max=1.0) | |
| pred_error = torch.acos(pred_error) * 180.0 / np.pi | |
| pred_error = pred_error.unsqueeze(1) # (B, 1, H, W) | |
| return pred_error | |
| def compute_normal_metrics(total_normal_errors): | |
| total_normal_errors = total_normal_errors.detach().cpu().numpy() | |
| num_pixels = total_normal_errors.shape[0] | |
| metrics = { | |
| 'mean': np.average(total_normal_errors), | |
| 'median': np.median(total_normal_errors), | |
| 'rmse': np.sqrt(np.sum(total_normal_errors * total_normal_errors) / num_pixels), | |
| 'a1': 100.0 * (np.sum(total_normal_errors < 5) / num_pixels), | |
| 'a2': 100.0 * (np.sum(total_normal_errors < 7.5) / num_pixels), | |
| 'a3': 100.0 * (np.sum(total_normal_errors < 11.25) / num_pixels), | |
| 'a4': 100.0 * (np.sum(total_normal_errors < 22.5) / num_pixels), | |
| 'a5': 100.0 * (np.sum(total_normal_errors < 30) / num_pixels) | |
| } | |
| return metrics | |
| def pad_input(orig_H, orig_W): | |
| if orig_W % 32 == 0: | |
| l = 0 | |
| r = 0 | |
| else: | |
| new_W = 32 * ((orig_W // 32) + 1) | |
| l = (new_W - orig_W) // 2 | |
| r = (new_W - orig_W) - l | |
| if orig_H % 32 == 0: | |
| t = 0 | |
| b = 0 | |
| else: | |
| new_H = 32 * ((orig_H // 32) + 1) | |
| t = (new_H - orig_H) // 2 | |
| b = (new_H - orig_H) - t | |
| return l, r, t, b | |
| def get_intrins_from_fov(new_fov, H, W, device): | |
| # NOTE: top-left pixel should be (0,0) | |
| if W >= H: | |
| new_fu = (W / 2.0) / np.tan(np.deg2rad(new_fov / 2.0)) | |
| new_fv = (W / 2.0) / np.tan(np.deg2rad(new_fov / 2.0)) | |
| else: | |
| new_fu = (H / 2.0) / np.tan(np.deg2rad(new_fov / 2.0)) | |
| new_fv = (H / 2.0) / np.tan(np.deg2rad(new_fov / 2.0)) | |
| new_cu = (W / 2.0) - 0.5 | |
| new_cv = (H / 2.0) - 0.5 | |
| new_intrins = torch.tensor([ | |
| [new_fu, 0, new_cu ], | |
| [0, new_fv, new_cv ], | |
| [0, 0, 1 ] | |
| ], dtype=torch.float32, device=device) | |
| return new_intrins | |
| def get_intrins_from_txt(intrins_path, device): | |
| # NOTE: top-left pixel should be (0,0) | |
| with open(intrins_path, 'r') as f: | |
| intrins_ = f.readlines()[0].split()[0].split(',') | |
| intrins_ = [float(i) for i in intrins_] | |
| fx, fy, cx, cy = intrins_ | |
| intrins = torch.tensor([ | |
| [fx, 0,cx], | |
| [ 0,fy,cy], | |
| [ 0, 0, 1] | |
| ], dtype=torch.float32, device=device) | |
| return intrins |