| """ 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) |
| 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): |
| |
| 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): |
| |
| 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 |
|
|
