def __init__(self, configer, is_debug=False):
self.configer = configer
self.is_debug = is_debug
self.aug_train_transform = aug_trans.AugCompose(self.configer)
self.img_transform = trans.Compose()
self.img_transform.add(trans.ResizeImage(configer))
self.img_transform.add(trans.ToTensor())
def reconstruct_right(args):
""" Function to reconstruct the right view of stereo pairs from left view
"""
# Since it is clear post-processing is better in all runs I have done, I will only
# save post-processed results. Unless explicitly stated otherwise.
# Also for Pilzer, the disparities are already post-processed by their own FuseNet.
do_post_processing = args.postprocessing and 'pilzer' not in args.architecture
input_height = args.input_height
input_width = args.input_width
output_directory = args.output_dir
file_names = os.listdir(args.data_dir)
file_names.sort()
file_names = [args.data_dir + '/' + file_name for file_name in file_names]
# Create model
model = create_architecture(args)
which_model = 'final' if args.load_final else 'best'
model.load_networks(which_model)
model.to_test()
# Make Fake loss module to use monodepthloss.generate_image_right
# Can use it with "import MonodepthLoss" and MonodepthLoss.generate_image...?
fake_loss = MonodepthLoss(args)
fake_loss = fake_loss.to(args.device)
for idx, left in enumerate(file_names):
left_image = Image.open(left)
input_size = (left_image.width, left_image.height)
resize = transforms.ResizeImage(train=False, size=(input_height, input_width))
totensor = transforms.ToTensor(train=False)
left_image = totensor(resize(left_image))
left_image = torch.stack((left_image, torch.flip(left_image, [2])))
# Make dicctionary to feed model.fit()
left_data = {'left_image': left_image}
# used in test time, wrapping `forward` in no_grad() so we don't save
# intermediate steps for backprop
with torch.no_grad():
# Estimate disparity
disps = model.fit(left_data)
disp_right_est = [d[:, 1, :, :].unsqueeze(1) for d in disps]
disp_right_est = disp_right_est[0]
# Using estimated disparity, apply it to left view and obtain right view
fake_right = fake_loss.generate_image_right(left_image.to(args.device), disp_right_est)
# convert Tensor(fake_right) to PIL image and save it!
output_name = os.path.splitext(os.path.basename(left))[0]
save_path = os.path.join(output_directory, '{}.png'.format(output_name))
save_right = torchvision.transforms.functional.to_pil_image(fake_right[0].cpu())
save_right = save_right.resize(input_size)
save_right.save(save_path)
if idx % 200 == 0:
print('Processed ' + save_path)
def check_reconstruct_right(args):
""" Function to reconstruct the right view of stereo pairs from left view
"""
# Since it is clear post-processing is better in all runs I have done, I will only
# save post-processed results. Unless explicitly stated otherwise.
# Also for Pilzer, the disparities are already post-processed by their own FuseNet.
do_post_processing = args.postprocessing and 'pilzer' not in args.architecture
input_height = args.input_height
input_width = args.input_width
input_left = args.left_view
output_directory = args.output_dir
# n_img, test_loader = prepare_dataloader(args, 'test')
# Create model
model = create_architecture(args)
which_model = 'final' if args.load_final else 'best'
model.load_networks(which_model)
model.to_test()
# Make Fake loss module to use monodepthloss.generate_image_right
# Can use it with "import MonodepthLoss" and MonodepthLoss.generate_image...?
fake_loss = MonodepthLoss(args)
fake_loss = fake_loss.to(args.device)
# used in test time, wrapping `forward` in no_grad() so we don't save
# intermediate steps for backprop
ext = ""
if args.load_final is False:
ext = "_best"
file_names = ['000025.png', '000031.png', '000036.png', '000049.png']
file_names = [
'/home/kishida/depthgan/sample_kitti_obj/' + file_name
for file_name in file_names
]
for filename in file_names:
# Conver input PIL image to Tensor with transformation
left_image = Image.open(filename)
input_size = (left_image.width, left_image.height)
resize = transforms.ResizeImage(train=False,
size=(input_height, input_width))
totensor = transforms.ToTensor(train=False)
left_image = totensor(resize(left_image))
left_image = torch.stack((left_image, torch.flip(left_image, [2])))
# Make dicctionary to feed model.fit()
left_data = {'left_image': left_image}
with torch.no_grad():
# Estimate disparity
disps = model.fit(left_data)
disp_right_est = [d[:, 1, :, :].unsqueeze(1) for d in disps]
disp_right_est = disp_right_est[0]
# Using estimated disparity, apply it to left view and obtain right view
print('reconstructing right view from left view')
fake_right = fake_loss.generate_image_right(
left_image.to(args.device), disp_right_est)
# convert Tensor(fake_right) to PIL image.
output_dir = os.path.dirname(filename)
output_name = os.path.splitext(os.path.basename(filename))[0]
model_name = os.path.basename(args.model_name)
save_path = os.path.join(
output_dir, '{}_rec_{}{}.jpg'.format(output_name, model_name,
ext))
save_right = torchvision.transforms.functional.to_pil_image(
fake_right[0].cpu())
print(input_size)
save_right = save_right.resize(input_size)
save_right.save(save_path)
print('Saved image : ' + save_path)
arguments = ['display', save_path]
subprocess.call(arguments)
def reconstruct_right(args):
""" Function to reconstruct the right view of stereo pairs from left view
"""
# Since it is clear post-processing is better in all runs I have done, I will only
# save post-processed results. Unless explicitly stated otherwise.
# Also for Pilzer, the disparities are already post-processed by their own FuseNet.
do_post_processing = args.postprocessing and 'pilzer' not in args.architecture
input_height = args.input_height
input_width = args.input_width
input_left = args.left_view
output_directory = args.output_dir
# n_img, test_loader = prepare_dataloader(args, 'test')
# Conver input PIL image to Tensor with transformation
left_image = Image.open(input_left)
resize = transforms.ResizeImage(train=False, size=(256, 512))
totensor = transforms.ToTensor(train=False)
left_image = totensor(resize(left_image))
left_image = torch.stack((left_image, torch.flip(left_image, [2])))
# Make dicctionary to feed model.fit()
left_data = {'left_image': left_image}
# Create model
model = create_architecture(args)
which_model = 'final' if args.load_final else 'best'
model.load_networks(which_model)
model.to_test()
# Make Fake loss module to use monodepthloss.generate_image_right
# Can use it with "import MonodepthLoss" and MonodepthLoss.generate_image...?
fake_loss = MonodepthLoss(args)
fake_loss = fake_loss.to(args.device)
# used in test time, wrapping `forward` in no_grad() so we don't save
# intermediate steps for backprop
with torch.no_grad():
# Estimate disparity
disps = model.fit(left_data)
disp_right_est = [d[:, 1, :, :].unsqueeze(1) for d in disps]
disp_right_est = disp_right_est[0]
# Using estimated disparity, apply it to left view and obtain right view
print('reconstructing right view from left view')
fake_right = fake_loss.generate_image_right(left_image.to(args.device),
disp_right_est)
disp_to_img = scipy.misc.imresize(disp_right_est[0].squeeze(),
[input_height, input_width])
print(type(disp_to_img))
print(disp_to_img.shape)
print(disp_to_img[100:110, 100:110])
Image.fromarray(disp_to_img).save('./output/000031_disp.jpg')
# convert Tensor(fake_right) to PIL image and save it!
print('Saving reconstructed right view...')
output_dir = os.path.dirname(input_left)
output_name = os.path.splitext(os.path.basename(input_left))[0]
model_name = os.path.basename(args.model_name)
save_path = os.path.join(
output_dir, '{}_rec_{}.jpg'.format(output_name, model_name))
save_right = torchvision.transforms.functional.to_pil_image(
fake_right[0].cpu())
save_right.save(save_path)
print('Saved image : ' + save_path)