def evaluate(cfg_path, model_path, gt_path, output_path):
filenames = readlines("../mono/datasets/splits/exp/val_files.txt")
cfg = Config.fromfile(cfg_path)
dataset = KITTIRAWDataset(cfg.data['in_path'],
filenames,
cfg.data['height'],
cfg.data['width'], [0],
is_train=False,
gt_depth_path=gt_path)
dataloader = DataLoader(dataset,
1,
shuffle=False,
num_workers=4,
pin_memory=True,
drop_last=False)
cfg.model['imgs_per_gpu'] = 1
model = MONO.module_dict[cfg.model['name']](cfg.model)
checkpoint = torch.load(model_path)
model.load_state_dict(checkpoint['state_dict'], strict=False)
model.cuda()
model.eval()
with torch.no_grad():
for batch_idx, inputs in enumerate(dataloader):
for key, ipt in inputs.items():
inputs[key] = ipt.cuda()
outputs = model(inputs)
img_path = os.path.join(output_path,
'img_{:0>4d}.jpg'.format(batch_idx))
plt.imsave(
img_path,
inputs[("color", 0, 0)][0].squeeze().transpose(0, 1).transpose(
1, 2).cpu().numpy())
disp = outputs[("disp", 0, 0)]
pred_disp, _ = disp_to_depth(disp, 0.1, 100)
pred_disp = pred_disp[0, 0].cpu().numpy()
pred_disp = cv2.resize(pred_disp,
(cfg.data['width'], cfg.data['height']))
img_path = os.path.join(output_path,
'disp_{:0>4d}.jpg'.format(batch_idx))
vmax = np.percentile(pred_disp, 95)
plt.imsave(img_path, pred_disp, cmap='magma', vmax=vmax)
print("\n-> Done!")
def evaluate(MODEL_PATH, CFG_PATH, GT_PATH):
filenames = readlines("../mono/datasets/splits/exp/val_files.txt")
cfg = Config.fromfile(CFG_PATH)
dataset = KITTIRAWDataset(cfg.data['in_path'],
filenames,
cfg.data['height'],
cfg.data['width'], [0],
is_train=False,
gt_depth_path=None)
dataloader = DataLoader(dataset,
2,
shuffle=False,
num_workers=1,
pin_memory=True,
drop_last=True)
cfg.model['imgs_per_gpu'] = 2
model = MONO.module_dict[cfg.model['name']](cfg.model)
checkpoint = torch.load(MODEL_PATH)
model.load_state_dict(checkpoint['state_dict'], strict=True)
model.cuda()
model.eval()
pred_disps = []
with torch.no_grad():
for batch_idx, inputs in enumerate(dataloader):
print(batch_idx)
for key, ipt in inputs.items():
inputs[key] = ipt.cuda()
outputs = model(inputs)
disp = outputs[("disp", 0, 0)]
# N = pred_disp.shape[0] // 2
# pred_disp = batch_post_process_disparity(pred_disp[:N], pred_disp[N:, :, ::-1])
pred_disp, _ = disp_to_depth(disp, 0.1, 100)
pred_disp = pred_disp.cpu()[:, 0].numpy()
pred_disps.append(pred_disp)
pred_disps = np.concatenate(pred_disps)
gt_depths = np.load(GT_PATH,
allow_pickle=True,
fix_imports=True,
encoding='latin1')["data"]
print("-> Evaluating")
if cfg.data['stereo_scale']:
print('using baseline')
else:
print('using mean scaling')
errors = []
ratios = []
for i in range(pred_disps.shape[0]):
gt_depth = gt_depths[i]
gt_height, gt_width = gt_depth.shape[:2]
pred_disp = pred_disps[i]
pred_disp = cv2.resize(pred_disp, (gt_width, gt_height))
pred_depth = 1 / pred_disp
mask = np.logical_and(gt_depth > MIN_DEPTH, gt_depth < MAX_DEPTH)
crop = np.array([
0.40810811 * gt_height, 0.99189189 * gt_height,
0.03594771 * gt_width, 0.96405229 * gt_width
]).astype(np.int32)
crop_mask = np.zeros(mask.shape)
crop_mask[crop[0]:crop[1], crop[2]:crop[3]] = 1
mask = np.logical_and(mask, crop_mask)
pred_depth = pred_depth[mask]
gt_depth = gt_depth[mask]
ratio = np.median(gt_depth) / np.median(pred_depth)
ratios.append(ratio)
if cfg.data['stereo_scale']:
ratio = STEREO_SCALE_FACTOR
pred_depth *= ratio
pred_depth[pred_depth < MIN_DEPTH] = MIN_DEPTH
pred_depth[pred_depth > MAX_DEPTH] = MAX_DEPTH
errors.append(compute_errors(gt_depth, pred_depth))
ratios = np.array(ratios)
med = np.median(ratios)
mean_errors = np.array(errors).mean(0)
print("Scaling ratios | med: {:0.3f} | std: {:0.3f}".format(
med, np.std(ratios / med)))
print("\n" +
("{:>}| " * 7
).format("abs_rel", "sq_rel", "rmse", "rmse_log", "a1", "a2", "a3"))
print(("&{:.3f} " * 7).format(*mean_errors.tolist()) + "\\\\")
print("\n-> Done!")
def odo(opt):
if opt.kitti:
filenames = readlines("../mono/datasets/splits/odom/test_files_{:02d}.txt".format(opt.sequence_id))
dataset = KITTIOdomDataset(opt.data_path,
filenames,
opt.height,
opt.width,
[0, 1],
is_train=False,
img_ext='.png',
gt_depth_path=None)
else:
dataset = FolderDataset(opt.data_path,
None,
opt.height,
opt.width,
[0, 1],
is_train=False,
img_ext='.png',
gt_depth_path=None)
dataloader = DataLoader(dataset,
1,
shuffle=False,
num_workers=4,
pin_memory=True,
drop_last=False)
pose_encoder = PoseEncoder(18, None, 2)
pose_decoder = PoseDecoder(pose_encoder.num_ch_enc)
checkpoint = torch.load(opt.model_path)
for name, param in pose_encoder.state_dict().items():
pose_encoder.state_dict()[name].copy_(checkpoint['state_dict']['PoseEncoder.' + name])
for name, param in pose_decoder.state_dict().items():
pose_decoder.state_dict()[name].copy_(checkpoint['state_dict']['PoseDecoder.' + name])
pose_encoder.cuda()
pose_encoder.eval()
pose_decoder.cuda()
pose_decoder.eval()
global_pose = np.identity(4)
poses = [global_pose[0:3, :].reshape(1, 12)]
with torch.no_grad():
for batch_idx, inputs in enumerate(dataloader):
for key, ipt in inputs.items():
inputs[key] = ipt.cuda()
all_color_aug = torch.cat([inputs[("color_aug", i, 0)] for i in [0,1]], 1)
axisangle, translation = pose_decoder(pose_encoder(all_color_aug))
g = transformation_from_parameters(axisangle[:, 0], translation[:, 0])
backward_transform = g.squeeze().cpu().numpy()#the transformation from frame +1 to frame 0
global_pose = global_pose @ np.linalg.inv(backward_transform)
poses.append(global_pose[0:3, :].reshape(1, 12))
poses = np.concatenate(poses, axis=0)
if opt.kitti:
filename = os.path.join(opt.result_dir, "{:02d}_pred.txt".format(opt.sequence_id))
else:
filename = os.path.join(opt.result_dir, "fm_ms_euroc_mh04_diff_3.txt")
np.savetxt(filename, poses, delimiter=' ', fmt='%1.8e')
if opt.kitti:
opt.eva_seqs = '{:02d}_pred'.format(opt.sequence_id)
pose_eval = kittiOdomEval(opt)
pose_eval.eval(toCameraCoord=False) # set the value according to the predicted results
print('saving into ', opt.result_dir)
def evaluate(data_path, model_path, sequence_id, height, width):
filenames = readlines(
"../mono/datasets/splits/odom/test_files_{:02d}.txt".format(
sequence_id))
dataset = KITTIOdomDataset(data_path,
filenames,
height,
width, [0, 1],
is_train=False,
img_ext='.png',
gt_depth_path=None)
dataloader = DataLoader(dataset,
1,
shuffle=False,
num_workers=4,
pin_memory=True,
drop_last=False)
pose_encoder = PoseEncoder(18, None, 2)
pose_decoder = PoseDecoder(pose_encoder.num_ch_enc)
checkpoint = torch.load(model_path)
for name, param in pose_encoder.state_dict().items():
pose_encoder.state_dict()[name].copy_(
checkpoint['state_dict']['PoseEncoder.' + name])
for name, param in pose_decoder.state_dict().items():
pose_decoder.state_dict()[name].copy_(
checkpoint['state_dict']['PoseDecoder.' + name])
pose_encoder.cuda()
pose_encoder.eval()
pose_decoder.cuda()
pose_decoder.eval()
pred_poses = []
print("-> Computing pose predictions")
with torch.no_grad():
for inputs in dataloader:
for key, ipt in inputs.items():
inputs[key] = ipt.cuda()
all_color_aug = torch.cat(
[inputs[("color_aug", i, 0)] for i in [0, 1]], 1)
features = pose_encoder(all_color_aug)
axisangle, translation = pose_decoder(features)
pred_poses.append(
transformation_from_parameters(axisangle[:, 0],
translation[:,
0]).cpu().numpy())
pred_poses = np.concatenate(pred_poses)
gt_poses_path = os.path.join(data_path, "poses",
"{:02d}.txt".format(sequence_id))
gt_global_poses = np.loadtxt(gt_poses_path).reshape(-1, 3, 4)
gt_global_poses = np.concatenate(
(gt_global_poses, np.zeros((gt_global_poses.shape[0], 1, 4))), 1)
gt_global_poses[:, 3, 3] = 1
gt_xyzs = gt_global_poses[:, :3, 3]
gt_local_poses = []
for i in range(1, len(gt_global_poses)):
gt_local_poses.append(
np.linalg.inv(
np.dot(np.linalg.inv(gt_global_poses[i - 1]),
gt_global_poses[i])))
ates = []
num_frames = gt_xyzs.shape[0]
track_length = 5
for i in range(0, num_frames - 1):
local_xyzs = np.array(dump_xyz(pred_poses[i:i + track_length - 1]))
gt_local_xyzs = np.array(
dump_xyz(gt_local_poses[i:i + track_length - 1]))
ates.append(compute_ate(gt_local_xyzs, local_xyzs))
print("\n odom_{} Trajectory error: {:0.3f}, std: {:0.3f}\n".format(
sequence_id, np.mean(ates), np.std(ates)))