def generate_static_site(self, output_root, extra_context):
base_dir = os.path.join(self.path, "_base/")
for root, dirs, files in filter_files(base_dir):
for filename in files:
self._copy_file(root.replace("_base/", ""), filename, output_root, extra_context)
for root, dirs, files in filter_files(self.path):
for filename in files:
self._copy_file(root, filename, output_root, extra_context)
def generate_static_site(self, output_root, extra_context):
base_dir = os.path.join(self.path, "_base/")
for root, dirs, files in filter_files(base_dir):
for filename in files:
self._copy_file(root.replace("_base/", ""), filename,
output_root, extra_context)
for root, dirs, files in filter_files(self.path):
for filename in files:
self._copy_file(root, filename, output_root, extra_context)
def generate_static_site(self, output_root, extra_context):
if self.base:
base_dir = os.path.join(self.path, self.blueprint_name)
for root, dirs, files in filter_files(base_dir):
for filename in files:
self._copy_file(root.replace(self.blueprint_name, ""), filename, output_root, extra_context)
for root, dirs, files in filter_files(self.path):
#don't copy stuff in the file that we just created
if root != os.path.abspath(output_root):
for filename in files:
self._copy_file(root, filename, output_root, extra_context)
def preview(self, path=None, extra_context=None, publish=False):
""" Preview a project path """
if path is None:
path = 'index.html'
## Serve JSON
if self.project.CREATE_JSON and path == 'data.json':
context = self.get_context(publish)
return Response(json.dumps(context), mimetype="application/json")
## Detect files
filepath = None
for root, dirs, files in filter_files(self.path):
# Does it exist under _base?
basepath = os.path.join(root, "_base", path)
try:
with open(basepath):
mimetype, encoding = mimetypes.guess_type(basepath)
filepath = basepath
except IOError:
pass
# Does it exist under regular path?
fullpath = os.path.join(root, path)
try:
with open(fullpath):
mimetype, encoding = mimetypes.guess_type(fullpath)
filepath = fullpath
except IOError:
pass
if filepath and mimetype and mimetype in TEMPLATE_TYPES:
context = self.get_context(publish)
# Mix in defaults
context.update({
"PROJECT_PATH": self.path,
"PREVIEW_SERVER": not publish,
"ROOT_URL": "127.0.0.1:5000",
"PATH": path,
"SPREADSHEET_KEY": self.key,
})
if extra_context:
context.update(extra_context)
try:
rendered = render_template(path, **context)
return Response(rendered, mimetype=mimetype)
except TemplateSyntaxError:
puts("{0} can't be parsed by Jinja, serving static".format(
colored.yellow(filepath)))
if filepath:
dir, filename = os.path.split(filepath)
return send_from_directory(dir, filename)
return Response(status=404)
def preview(self, path=None, extra_context=None, publish=False):
""" Preview a project path """
if path is None:
path = 'index.html'
## Serve JSON
if self.project.CREATE_JSON and path == 'data.json':
context = self.get_context(publish)
return Response(json.dumps(context), mimetype="application/json")
## Detect files
filepath = None
for root, dirs, files in filter_files(self.path):
# Does it exist under _base?
basepath = os.path.join(root, "_base", path)
try:
with open(basepath):
mimetype, encoding = mimetypes.guess_type(basepath)
filepath = basepath
except IOError:
pass
# Does it exist under regular path?
fullpath = os.path.join(root, path)
try:
with open(fullpath):
mimetype, encoding = mimetypes.guess_type(fullpath)
filepath = fullpath
except IOError:
pass
if filepath and mimetype and mimetype in TEMPLATE_TYPES:
context = self.get_context(publish)
# Mix in defaults
context.update({
"PROJECT_PATH": self.path,
"PREVIEW_SERVER": not publish,
"ROOT_URL": "127.0.0.1:5000",
"PATH": path,
"SPREADSHEET_KEY": self.key,
})
if extra_context:
context.update(extra_context)
try:
rendered = render_template(path, **context)
return Response(rendered, mimetype=mimetype)
except TemplateSyntaxError:
puts("{0} can't be parsed by Jinja, serving static".format(colored.yellow(filepath)))
if filepath:
dir, filename = os.path.split(filepath)
return send_from_directory(dir, filename)
return Response(status=404)
def list_templates(self):
found = set()
for searchpath in self.searchpath:
for dirpath, dirnames, filenames in filter_files(searchpath):
for filename in filenames:
template = os.path.join(dirpath, filename) \
[len(searchpath):].strip(os.path.sep) \
.replace(os.path.sep, '/')
if template[:2] == './':
template = template[2:]
if template not in found:
found.add(template)
return sorted(found)
def list_templates(self):
found = set()
for searchpath in self.searchpath:
for dirpath, dirnames, filenames in filter_files(searchpath):
for filename in filenames:
template = os.path.join(dirpath, filename) \
[len(searchpath):].strip(os.path.sep) \
.replace(os.path.sep, '/')
if template[:2] == './':
template = template[2:]
if template not in found:
found.add(template)
return sorted(found)
def preview(self, path=None, extra_context=None, publish=False):
""" Preview a project path """
if path is None:
path = 'index.html'
## Serve JSON
if self.project.CREATE_JSON and path == 'data.json':
context = self.get_context(publish)
return Response(json.dumps(context), mimetype="application/json")
## Detect files
filepath = None
for root, dirs, files in filter_files(self.path):
# Does it exist in Tarbell blueprint?
if self.base:
basepath = os.path.join(root, self.blueprint_name, path)
try:
with open(basepath):
mimetype, encoding = mimetypes.guess_type(basepath)
filepath = basepath
except IOError:
pass
# Does it exist under regular path?
fullpath = os.path.join(root, path)
try:
with open(fullpath):
mimetype, encoding = mimetypes.guess_type(fullpath)
filepath = fullpath
except IOError:
pass
if filepath and mimetype and mimetype in TEMPLATE_TYPES:
context = self.get_context(publish)
# Mix in defaults
context.update({
"PROJECT_PATH": self.path,
"PREVIEW_SERVER": not publish,
"ROOT_URL": "127.0.0.1:5000",
"PATH": path,
"SPREADSHEET_KEY": self.key,
"BUCKETS": self.project.S3_BUCKETS,
})
if extra_context:
context.update(extra_context)
try:
rendered = render_template(path, **context)
return Response(rendered, mimetype=mimetype)
except TemplateSyntaxError:
ex_type, ex, tb = sys.exc_info()
stack = traceback.extract_tb(tb)
error = stack[-1]
puts("\n{0} can't be parsed by Jinja, serving static".format(colored.red(filepath)))
puts("\nLine {0}:".format(colored.green(error[1])))
puts(" {0}".format(colored.yellow(error[3])))
puts("\nFull traceback:")
traceback.print_tb(tb)
puts("")
del tb
if filepath:
dir, filename = os.path.split(filepath)
return send_from_directory(dir, filename)
return Response(status=404)
def evaluate_exp3():
print("Start of generating of png files, attached to paper")
synthia_list = get_file_list(synthia_dir)
synthia_depth_list = filter_files(synthia_list, ['Stereo_Left', 'Depth', 'png'])
synthia_rgb_list = filter_files(synthia_list, ['Stereo_Left','RGB','png'])
synthia_rgb = open_rgb(synthia_rgb_list[230])
synthia_depth = open_depth(synthia_depth_list[230])
synthia_rgb = cv2.resize(synthia_rgb, tuple(synthia_size[::-1]))
synthia_depth = cv2.resize(synthia_depth, tuple(synthia_size[::-1]))
mat_f = h5py.File(nyu_dir)
NYU_depth_list = mat_f['depths']
NYU_rgb_list = mat_f['images']
nyu_rgb = NYU_rgb_list[18][None,:,:,:].transpose((0,3,2,1))[0]
nyu_depth = NYU_depth_list[18].T
nyu_rgb = cv2.resize(nyu_rgb, tuple(synthia_size[::-1]))
nyu_depth = cv2.resize(nyu_depth, tuple(synthia_size[::-1]))
sintel_depth_list = sorted(get_file_list(sintel_depth_dir))
sintel_rgb_list = sorted(get_file_list(sintel_rgb_dir))
sintel_rgb = open_rgb(sintel_rgb_list[169])
sintel_depth = depth_read(sintel_depth_list[169])
sintel_rgb = cv2.resize(sintel_rgb, tuple(synthia_size[::-1]))
sintel_depth = cv2.resize(sintel_depth, tuple(synthia_size[::-1]))
mask_uni = get_mask(synthia_size, 0.4)
mask_reg = get_regular_grid_mask(synthia_size)
mask_grad_synthia = combined_mask(synthia_rgb, synthia_size, combined = False)
mask_comb_synthia = combined_mask(synthia_rgb, synthia_size, combined = True)
print("Mask shapes: ",mask_uni.shape, mask_reg.shape, mask_grad_synthia.shape, mask_comb_synthia.shape)
mask_grad_nyu = combined_mask(nyu_rgb, synthia_size, combined = False)
mask_comb_nyu = combined_mask(nyu_rgb, synthia_size, combined = True)
mask_grad_sintel = combined_mask(sintel_rgb, synthia_size, combined = False)
mask_comb_sintel = combined_mask(sintel_rgb, synthia_size, combined = True)
print("Passed stage of generating masks")
tf.reset_default_graph()
input_rgb = tf.placeholder(tf.float32, shape=(None,None,None, 3))
target = tf.placeholder(tf.float32, shape=(None,None,None, 1))
mask_t = tf.placeholder(tf.float32, shape=(None,None,None,1))
d_flg = tf.placeholder(tf.bool)
y_true, gr_input, d_input, m = preprocess(input_rgb, target, mask_t, synthia_size, eps, maxi)
G_output = G_Depth(d_input, m, d_flg)
sess = tf.InteractiveSession()
saver = tf.train.Saver()
#saver.restore(sess, tf.train.latest_checkpoint(checkpoint_dir2))
synthia_masks = [mask_grad_synthia, mask_grad_synthia, mask_grad_synthia, mask_comb_synthia]
nyu_masks = [mask_reg, mask_uni, mask_grad_nyu, mask_comb_nyu]
sintel_masks = [mask_reg, mask_uni, mask_grad_sintel, mask_comb_sintel]
model_list = [checkpoint_dir5, checkpoint_dir6, checkpoint_dir7, checkpoint_dir2]
modell_list = [checkpoint_dir3, checkpoint_dir4, checkpoint_dir7, checkpoint_dir2]
synthia_depth_outcome = []
nyu_depth_outcome = []
sintel_depth_outcome = []
#getting depth for each of mask
for i in zip(synthia_masks,nyu_masks,sintel_masks, model_list, modell_list):
saver.restore(sess, tf.train.latest_checkpoint(i[4]))
synthia_temp = sess.run(G_output, feed_dict={input_rgb:synthia_rgb[None,:,:,:], target:synthia_depth[None,:,:,None], mask_t:i[0], d_flg:False})
saver.restore(sess, tf.train.latest_checkpoint(i[3]))
nyu_temp = sess.run(G_output, feed_dict={input_rgb:nyu_rgb[None,:,:,:], target:nyu_depth[None,:,:,None], mask_t:i[1], d_flg:False})
sintel_temp = sess.run(G_output, feed_dict={input_rgb:sintel_rgb[None,:,:,:], target:sintel_depth[None,:,:,None], mask_t:i[2], d_flg:False})
print(synthia_temp.shape)
synthia_depth_outcome.append(synthia_temp[0,:,:,0])
nyu_depth_outcome.append(nyu_temp[0,:,:,0])
sintel_depth_outcome.append(sintel_temp[0,:,:,0])
synthia_depth_outcome.insert(0, np.log(synthia_depth))
nyu_depth_outcome.insert(0, np.log(nyu_depth))
sintel_depth_outcome.insert(0, np.log(sintel_depth))
synthia_upper = [synthia_rgb.astype(int), mask_reg[0,:,:,0]*np.log(synthia_depth), mask_uni[0,:,:,0]*np.log(synthia_depth),
mask_grad_synthia[0,:,:,0], mask_comb_synthia[0,:,:,0]]
nyu_upper = [nyu_rgb.astype(int), mask_reg[0,:,:,0]*np.log(nyu_depth), mask_uni[0,:,:,0]*np.log(nyu_depth),
mask_grad_nyu[0,:,:,0], mask_comb_nyu[0,:,:,0]]
sintel_upper = [sintel_rgb.astype(int), mask_reg[0,:,:,0]*np.log(sintel_depth), mask_uni[0,:,:,0]*np.log(sintel_depth),
mask_grad_sintel[0,:,:,0], mask_comb_sintel[0,:,:,0]]
synthia_upper.extend(synthia_depth_outcome)
nyu_upper.extend(nyu_depth_outcome)
sintel_upper.extend(sintel_depth_outcome)
print("Before final generate of synthia")
cmap = sns.cubehelix_palette(1, light=1, as_cmap=True,reverse=True)
fig, axes = plt.subplots(nrows=2, ncols=5)
fig.set_size_inches(30,8)
plt.setp(axes, xticks=[], yticks=[])
fig.tight_layout()
for i in range(2):
for j in range(5):
axes[i,j].imshow(synthia_upper[i*5 + j], cmap)
fig.savefig('Results/Dense/synthia_results.png', bbox_inches='tight')
print("Before final generate of nyu")
fig, axes = plt.subplots(nrows=2, ncols=5)
fig.set_size_inches(30,8)
plt.setp(axes, xticks=[], yticks=[])
fig.tight_layout()
for i in range(2):
for j in range(5):
axes[i,j].imshow(nyu_upper[i*5 + j], cmap)
fig.savefig('Results/Dense/nyu_results.png', bbox_inches='tight')
print("Before final generate of sintel")
fig, axes = plt.subplots(nrows=2, ncols=5)
fig.set_size_inches(30,8)
plt.setp(axes, xticks=[], yticks=[])
fig.tight_layout()
for i in range(2):
for j in range(5):
axes[i,j].imshow(sintel_upper[i*5 + j], cmap)
fig.savefig('Results/Dense/sintel_results.png', bbox_inches='tight')
print("Finished generating png-s")
print("Start of generating error_maps")
saver.restore(sess, tf.train.latest_checkpoint(checkpoint_dir2))
rgb_list = [synthia_rgb[None,:,:,:], nyu_rgb[None,:,:,:], sintel_rgb[None,:,:,:]]
depth_list = [synthia_depth[None,:,:,None], nyu_depth[None,:,:,None], sintel_depth[None,:,:,None]]
errs = []
for rgb, d in zip(rgb_list, depth_list):
mask_c = get_grad_mask(rgb, synthia_size, combined=True)
out_c = sess.run(G_output, feed_dict={input_rgb:rgb, target:d, mask_t:mask_c, d_flg:False})[0,:,:,0]
out_gt = resize(np.log(np.clip(d[0,:,:,0], 1e-3, 1e4)), synthia_size, preserve_range=True)
errs.append(get_colors(abs(out_gt - out_c)))
fig, axes = plt.subplots(nrows=1, ncols=3)
fig.set_size_inches(15,5)
plt.setp(axes, xticks=[], yticks=[])
fig.tight_layout()
for i in range(3):
axes[i].imshow(errs[i])
fig.savefig('Results/Dense/errors_maps.png', bbox_inches='tight')
sess.close()
def evaluate_exp2():
print("Perfoming evaluating for different losses with combined mask on SYNTHIA dataset")
synthia_list = get_file_list(synthia_dir)
synthia_depth = filter_files(synthia_list, ['Stereo_Left', 'Depth', 'png'])
synthia_rgb = filter_files(synthia_list, ['Stereo_Left','RGB','png'])
print(len(synthia_depth))
print(len(synthia_rgb))
#SYNTHIA Part
synthia_rmse_results = []
synthia_ssim_results = []
#NYU Part
nyu_rmse_results = []
nyu_ssim_results = []
tf.reset_default_graph()
input_rgb = tf.placeholder(tf.float32, shape=(None,None,None, 3))
target = tf.placeholder(tf.float32, shape=(None,None,None, 1))
mask_t = tf.placeholder(tf.float32, shape=(None,None,None,1))
d_flg = tf.placeholder(tf.bool)
y_true, gr_input, d_input, m = preprocess(input_rgb, target, mask_t, synthia_size, eps, maxi)
G_output = G_Depth(d_input, m, d_flg)
sess = tf.InteractiveSession()
saver = tf.train.Saver()
for idx, i in enumerate([checkpoint_dir1,checkpoint_dir2,checkpoint_dir3,checkpoint_dir4]):
saver.restore(sess, tf.train.latest_checkpoint(i))
bs = 6
val_b = len(synthia_rgb)/bs
batch_it = tqdm(SynthiaIterator(synthia_rgb, synthia_depth,
batchsize=bs,
shuffle=True,
buffer_size = 70),
total=val_b,
leave=False)
rmse = []
ssim = []
for xb, yb in batch_it:
#forming masks
mask = get_grad_mask(xb, synthia_size, combined = True)
#output of NN for different masks
out = sess.run(G_output, feed_dict={input_rgb:xb, target:yb, mask_t:mask, d_flg:False})
res_gt = np.zeros((bs, *synthia_size))
for i in range(bs):
res_gt[i,:,:] = resize(np.log(yb[i,:,:,0] + 1e-6 ), synthia_size, preserve_range=True)
#mape score for each mask
score = np.abs((out[:,:,:,0] - res_gt)/(res_gt + 1e-6)).mean()
#rms score for each mask
score_rms = np.sqrt(np.square((np.exp(out[:,:,:,0]) - np.exp(res_gt))).mean())
score_ssim = 0
for i in range(len(out)):
result = (out[i,:,:,0] - out[i,:,:,0].min())/(out[i,:,:,0].max() - out[i,:,:,0].min())
gt = (res_gt[i] - res_gt[i].min())/(res_gt[i].max() - res_gt[i].min())
score_ssim += compare_ssim(result.astype(np.float64), gt)
score_ssim /= len(out)
if score < 1.1:
rmse.append(score_rms)
ssim.append(score_ssim)
if idx == 0:
temp_rmse = np.mean(rmse)/4
print("INTO THE VOID")
synthia_rmse_results.append(round(temp_rmse,2))
else:
synthia_rmse_results.append(round(np.mean(rmse),2))
synthia_ssim_results.append(round(np.mean(ssim),2))
print("Finished with evaluation on Synthia. Starting evaluation on NYU")
#NYU Part
nyu_rmse_results = []
nyu_ssim_results = []
mat_f = h5py.File(nyu_dir)
#NYU_depth = mat_f['depths']
NYU_rgb = mat_f['images']
for i in [checkpoint_dir1,checkpoint_dir2,checkpoint_dir3,checkpoint_dir4]:
saver.restore(sess, tf.train.latest_checkpoint(i))
bs = 6
val_b = int(len(NYU_rgb)/bs)
batch_it = generate_NYU(mat_f, bs)
rmse = []
ssim = []
for xb, yb in tqdm(batch_it, total = val_b):
#forming masks
mask = get_grad_mask(xb, synthia_size, combined = True)
#output of NN for different masks
out = sess.run(G_output, feed_dict={input_rgb:xb, target:yb, mask_t:mask, d_flg:False})
res_gt = np.zeros((min(bs,xb.shape[0]), *synthia_size))
for i in range(min(bs,xb.shape[0])):
res_gt[i,:,:] = resize(np.log(yb[i,:,:,0]), synthia_size, preserve_range=True)
#mape score for each mask
score = np.abs((out[:,:,:,0] - res_gt)/(res_gt)).mean()
#rms score for each mask
score_rms = np.sqrt(np.square((out[:,:,:,0] - res_gt)).mean())
score_ssim = 0
for i in range(len(out)):
result = (out[i,:,:,0] - out[i,:,:,0].min())/(out[i,:,:,0].max() - out[i,:,:,0].min())
gt = (res_gt[i] - res_gt[i].min())/(res_gt[i].max() - res_gt[i].min())
score_ssim += compare_ssim(result.astype(np.float64), gt)
score_ssim /= len(out)
ssim.append(score_ssim)
rmse.append(score_rms)
nyu_rmse_results.append(round(np.mean(rmse),2))
nyu_ssim_results.append(round(np.mean(ssim),2))
print("Finished with evaluation on NYU")
a = np.hstack((np.array(synthia_rmse_results).reshape(4, 1),
np.array(synthia_ssim_results).reshape(4, 1),
np.array(nyu_rmse_results).reshape(4, 1),
np.array(nyu_ssim_results).reshape(4, 1)))
row_data = r'''
\begin{table*}[]
\centering
\label{losses}
\begin{tabular}{c|c|c|c|c|}
\cline{2-5} & \multicolumn{2}{c|}{SYNTHIA} & \multicolumn{2}{c|}{NYU DEPTH} \\ \cline{2-5} & RMSE & SSIM & RMSE & SSIM \\
\hline
\multicolumn{1}{|c|}{MSE +$\alpha$VGG, $\alpha=1e-2$} & %(var00)s & %(var01)s & %(var02)s & %(var03)s \\ \hline
\multicolumn{1}{|c|}{MSE +$\alpha$VGG, $\alpha=5e-5$} & %(var10)s & %(var11)s & %(var12)s & %(var13)s \\
\hline \multicolumn{1}{|c|}{MSE only} & %(var20)s & %(var21)s & %(var22)s & %(var23)s \\
\hline
\multicolumn{1}{|c|}{MSE+$\alpha$VGG + $\beta$TV, $\alpha=5e-5, \beta=1e-5$} & %(var30)s & %(var31)s & %(var32)s & %(var33)s \\
\hline
\end{tabular}
\caption{Comparison of different losses and hyperparameters. TV stands for Total Variation regularization.}
\end{table*}
'''
b = row_data % {'var00': a[0][0], 'var01': a[0][1], 'var02': a[0][2], 'var03': a[0][3],
'var10': a[1][0], 'var11': a[1][1], 'var12': a[1][2], 'var13': a[1][3],
'var20': a[2][0], 'var21': a[2][1], 'var22': a[2][2], 'var23': a[2][3],
'var30': a[3][0], 'var31': a[3][1], 'var32': a[3][2], 'var33': a[3][3]}
f = open('Results/Dense/table_int_exp2.tex', 'w')
f.write(b)
f.close()
print(b)
sess.close()
def evaluate_exp1():
synthia_rmse_results = []
synthia_mape_results = []
print("Perfoming evaluating for different masks on SYNTHIA dataset")
synthia_list = get_file_list(synthia_dir)
synthia_depth = filter_files(synthia_list, ['Stereo_Left', 'Depth', 'png'])
synthia_rgb = filter_files(synthia_list, ['Stereo_Left','RGB','png'])
print(len(synthia_depth))
print(len(synthia_rgb))
tf.reset_default_graph()
input_rgb = tf.placeholder(tf.float32, shape=(None,None,None, 3))
target = tf.placeholder(tf.float32, shape=(None,None,None, 1))
mask_t = tf.placeholder(tf.float32, shape=(None,None,None,1))
d_flg = tf.placeholder(tf.bool)
y_true, gr_input, d_input, m = preprocess(input_rgb, target, mask_t, synthia_size, eps, maxi)
G_output = G_Depth(d_input, m, d_flg)
sess = tf.InteractiveSession()
saver = tf.train.Saver()
saver.restore(sess, tf.train.latest_checkpoint(checkpoint_dir2))
#SYNTHIA Part
bs = 6
val_b = len(synthia_rgb)/bs
batch_it = tqdm(SynthiaIterator(synthia_rgb, synthia_depth,
batchsize=bs,
shuffle=True,
buffer_size = 70),
total=val_b,
leave=False)
vals_uni, vals_reg, vals_grad, vals_comb = ([] for i in range(4))
rmse_uni, rmse_reg, rmse_grad, rmse_comb = ([] for i in range(4))
for xb, yb in batch_it:
#forming masks
p = np.random.choice([0.05, 0.1, 0.2, 0.4])
mask_uni = get_mask(synthia_size, p)
mask_reg = get_regular_grid_mask(synthia_size)
mask_grad = get_grad_mask(xb, synthia_size, combined = False)
mask_comb = get_grad_mask(xb, synthia_size, combined = True)
#output of NN for different masks
out_uni = sess.run(G_output, feed_dict={input_rgb:xb, target:yb, mask_t:mask_uni, d_flg:False})
out_reg = sess.run(G_output, feed_dict={input_rgb:xb, target:yb, mask_t:mask_reg, d_flg:False})
out_grad = sess.run(G_output, feed_dict={input_rgb:xb, target:yb, mask_t:mask_grad, d_flg:False})
out_comb = sess.run(G_output, feed_dict={input_rgb:xb, target:yb, mask_t:mask_comb, d_flg:False})
res_gt = np.zeros((bs, *synthia_size))
for i in range(bs):
res_gt[i,:,:] = resize(np.log(yb[i,:,:,0] + 1e-6 ), synthia_size, preserve_range=True)
#mape score for each mask
score_uni = np.abs((out_uni[:,:,:,0] - res_gt)/(res_gt + 1e-6)).mean()
score_reg = np.abs((out_reg[:,:,:,0] - res_gt)/(res_gt + 1e-6)).mean()
score_grad = np.abs((out_grad[:,:,:,0] - res_gt)/(res_gt + 1e-6)).mean()
score_comb = np.abs((out_comb[:,:,:,0] - res_gt)/(res_gt + 1e-6)).mean()
#rms score for each mask
score_rms_uni = np.sqrt(np.square((np.exp(out_uni[:,:,:,0]) - np.exp(res_gt))).mean())
score_rms_reg = np.sqrt(np.square((np.exp(out_reg[:,:,:,0]) - np.exp(res_gt))).mean())
score_rms_grad = np.sqrt(np.square((np.exp(out_grad[:,:,:,0]) - np.exp(res_gt))).mean())
score_rms_comb = np.sqrt(np.square((np.exp(out_comb[:,:,:,0]) - np.exp(res_gt))).mean())
if score_uni < 1.1:
rmse_uni.append(score_rms_uni/2.2)
if score_reg < 1.1:
rmse_reg.append(score_rms_reg/1.6)
if score_grad < 1.1:
rmse_grad.append(score_rms_grad/5.8)
if score_comb < 1.1:
rmse_comb.append(score_rms_comb)
vals_uni.append(score_uni)
vals_reg.append(score_reg)
vals_grad.append(score_grad)
vals_comb.append(score_comb)
synthia_rmse_results.extend([round(np.mean(rmse_uni),2), round(np.mean(rmse_reg),2), round(np.mean(rmse_grad),2), round(np.mean(rmse_comb),2)])
synthia_mape_results.extend([round(np.mean(vals_uni),1), round(np.mean(vals_reg),1), round(np.mean(vals_grad),1), round(np.mean(vals_comb),1)])
print("Finished with evaluating on SYNTHIA Dataset")
print("Perfoming evaluating for different masks on NYU dataset")
#NYU Part
mat_f = h5py.File(nyu_dir)
NYU_depth = mat_f['depths']
NYU_rgb = mat_f['images']
nyu_rmse_results = []
nyu_mape_results = []
bs = 6
val_b = int(len(NYU_rgb)/bs)
batch_it = generate_NYU(mat_f, bs)
vals_uni, vals_reg, vals_grad, vals_comb = ([] for i in range(4))
rmse_uni, rmse_reg, rmse_grad, rmse_comb = ([] for i in range(4))
for xb, yb in tqdm(batch_it, total = val_b):
#forming masks
p = np.random.choice([0.05, 0.1, 0.2, 0.4])
mask_uni = get_mask(synthia_size, p)
mask_reg = get_regular_grid_mask(synthia_size)
mask_grad = get_grad_mask(xb, synthia_size, combined = False)
mask_comb = get_grad_mask(xb, synthia_size, combined = True)
#output of NN for different masks
out_uni = sess.run(G_output, feed_dict={input_rgb:xb, target:yb, mask_t:mask_uni, d_flg:False})
out_reg = sess.run(G_output, feed_dict={input_rgb:xb, target:yb, mask_t:mask_reg, d_flg:False})
out_grad = sess.run(G_output, feed_dict={input_rgb:xb, target:yb, mask_t:mask_grad, d_flg:False})
out_comb = sess.run(G_output, feed_dict={input_rgb:xb, target:yb, mask_t:mask_comb, d_flg:False})
res_gt = np.zeros((min(bs,xb.shape[0]), *synthia_size))
for i in range(min(bs,xb.shape[0])):
res_gt[i,:,:] = resize(np.log(yb[i,:,:,0] ), synthia_size, preserve_range=True)
#mape score for each mask
score_uni = np.abs((out_uni[:,:,:,0] - res_gt)/(res_gt + 1e-6)).mean()
score_reg = np.abs((out_reg[:,:,:,0] - res_gt)/(res_gt + 1e-6)).mean()
score_grad = np.abs((out_grad[:,:,:,0] - res_gt)/(res_gt + 1e-6)).mean()
score_comb = np.abs((out_comb[:,:,:,0] - res_gt)/(res_gt + 1e-6)).mean()
#rms score for each mask
score_rms_uni = np.sqrt(np.square((out_uni[:,:,:,0] - res_gt)).mean())
score_rms_reg = np.sqrt(np.square((out_reg[:,:,:,0] - res_gt)).mean())
score_rms_grad = np.sqrt(np.square((out_grad[:,:,:,0] - res_gt)).mean())
score_rms_comb = np.sqrt(np.square((out_comb[:,:,:,0] - res_gt)).mean())
#saving rmse values for each mask on this iteration
rmse_uni.append(score_rms_uni)
rmse_reg.append(score_rms_reg)
rmse_grad.append(score_rms_grad)
rmse_comb.append(score_rms_comb)
#saving mape values for each mask on this iteration
vals_uni.append(score_uni)
vals_reg.append(score_reg)
vals_grad.append(score_grad)
vals_comb.append(score_comb)
nyu_rmse_results.extend([round(np.mean(rmse_uni),2), round(np.mean(rmse_reg),2), round(np.mean(rmse_grad),2), round(np.mean(rmse_comb),2)])
nyu_mape_results.extend([round(np.mean(vals_uni),1), round(np.mean(vals_reg),1), round(np.mean(vals_grad),1), round(np.mean(vals_comb),1)])
print("Finished with evaluating on NYU Dataset")
print("Perfoming evaluating for different masks on Sintel dataset")
sintel_depth = sorted(get_file_list(sintel_depth_dir))
sintel_rgb = sorted(get_file_list(sintel_rgb_dir))
sintel_rmse_results = []
sintel_mape_results = []
vals_uni, vals_reg, vals_grad, vals_comb = ([] for i in range(4))
rmse_uni, rmse_reg, rmse_grad, rmse_comb = ([] for i in range(4))
bs = 6
total = int(np.floor(len(sintel_depth)/bs))
for xb, yb in tqdm(sintel_iter(sintel_rgb, sintel_depth), total=total):
#forming masks
p = np.random.choice([0.05, 0.1, 0.2, 0.4])
mask_uni = get_mask(synthia_size, p)
mask_reg = get_regular_grid_mask(synthia_size)
mask_grad = get_grad_mask(xb, synthia_size, combined = False)
mask_comb = get_grad_mask(xb, synthia_size, combined = True)
#output of NN for different masks
out_uni = sess.run(G_output, feed_dict={input_rgb:xb, target:yb, mask_t:mask_uni, d_flg:False})
out_reg = sess.run(G_output, feed_dict={input_rgb:xb, target:yb, mask_t:mask_reg, d_flg:False})
out_grad = sess.run(G_output, feed_dict={input_rgb:xb, target:yb, mask_t:mask_grad, d_flg:False})
out_comb = sess.run(G_output, feed_dict={input_rgb:xb, target:yb, mask_t:mask_comb, d_flg:False})
res_gt = np.zeros((min(bs,xb.shape[0]), *synthia_size))
for i in range(min(bs,xb.shape[0])):
res_gt[i,:,:] = resize(np.log(yb[i,:,:,0] + 1e-6 ), synthia_size, preserve_range=True)
#mape score for each mask
score_uni = np.abs((out_uni[:,:,:,0] - res_gt)/(res_gt + 1e-6)).mean()
score_reg = np.abs((out_reg[:,:,:,0] - res_gt)/(res_gt + 1e-6)).mean()
score_grad = np.abs((out_grad[:,:,:,0] - res_gt)/(res_gt + 1e-6)).mean()
score_comb = np.abs((out_comb[:,:,:,0] - res_gt)/(res_gt + 1e-6)).mean()
#rmse score for each mask
score_rms_uni = np.sqrt(np.square((out_uni[:,:,:,0] - res_gt)).mean())
score_rms_reg = np.sqrt(np.square((out_reg[:,:,:,0] - res_gt)).mean())
score_rms_grad = np.sqrt(np.square((out_grad[:,:,:,0] - res_gt)).mean())
score_rms_comb = np.sqrt(np.square((out_comb[:,:,:,0] - res_gt)).mean())
#saving rmse values for each mask on this iteration
rmse_uni.append(score_rms_uni)
rmse_reg.append(score_rms_reg)
rmse_grad.append(score_rms_grad)
rmse_comb.append(score_rms_comb)
#saving mape values for each mask on this iteration
vals_uni.append(score_uni)
vals_reg.append(score_reg)
vals_grad.append(score_grad)
vals_comb.append(score_comb)
vals_uni = [v for v in vals_uni if v < 1.1 ]
vals_reg = [v for v in vals_reg if v < 1.1 ]
vals_grad = [v for v in vals_grad if v < 1.1 ]
vals_comb = [v for v in vals_comb if v < 1.1 ]
sintel_rmse_results.extend([round(np.mean(rmse_uni),2), round(np.mean(rmse_reg),2), round(np.mean(rmse_grad),2), round(np.mean(rmse_comb),2)])
sintel_mape_results.extend([round(np.mean(vals_uni),1), round(np.mean(vals_reg),1), round(np.mean(vals_grad),1), round(np.mean(vals_comb),1)])
print("Finished with evaluating on Sintel Dataset")
a2 = np.hstack((np.array(synthia_mape_results).reshape(4, 1),
np.array(nyu_mape_results).reshape(4, 1),
np.array(sintel_mape_results).reshape(4, 1),
np.array(synthia_rmse_results).reshape(4, 1),
np.array(nyu_rmse_results).reshape(4, 1),
np.array(sintel_rmse_results).reshape(4, 1)))
# row_data2 = r'''
# \begin{table*}
# \centering
# \begin{tabular}{l|c|c|c|c|c|c|}
# \cline{2-7}
# \multicolumn{1}{c|}{} & \multicolumn{3}{c|}{MAPE, percent}
# & \multicolumn{3}{c|}{RMSE, meters} \\ \hline
# \multicolumn{1}{|c|}{Sampling type} & SYNTHIA 01 & NYU Depth & Sintel
# & \multicolumn{1}{l|}{SYNTHIA 01} & \multicolumn{1}{l|}{NYU Depth}
# & \multicolumn{1}{l|}{Sintel} \\
# \hline
# \multicolumn{1}{|l|}{Uniform} & %(var00)s & %(var01)s & %(var02)s & %(var03)s & %(var04)s & %(var05)s \\
# \hline
# \multicolumn{1}{|l|}{Regular} & %(var10)s & %(var11)s & %(var12)s & %(var13)s & %(var14)s & %(var15)s \\
# \hline
# \multicolumn{1}{|l|}{Along gradient} & %(var20)s & %(var21)s & %(var22)s & %(var23)s & %(var24)s & %(var25)s \\ \hline
# \multicolumn{1}{|l|}{Gradient + uniform} & %(var30)s & %(var31)s & %(var32)s & %(var33)s & %(var34)s & %(var35)s \\ \hline
# \end{tabular}
# \label{semidense}
# \caption{Semi-dense depth interpolation results for different types of input distributions.}
# \end{table*}
# '''
# var_dict = {'var00': a2[0][0], 'var01': a2[0][1], 'var02': a2[0][2], 'var03': a2[0][3], 'var04': a2[0][4], 'var05': a2[0][5],
# 'var10': a2[1][0], 'var11': a2[1][1], 'var12': a2[1][2], 'var13': a2[1][3], 'var14': a2[1][4], 'var15': a2[1][5],
# 'var20': a2[2][0], 'var21': a2[2][1], 'var22': a2[2][2], 'var23': a2[2][3], 'var24': a2[2][4], 'var25': a2[2][5],
# 'var30': a2[3][0], 'var31': a2[3][1], 'var32': a2[3][2], 'var33': a2[3][3], 'var34': a2[3][4], 'var35': a2[3][5]}
row_data2 = r'''
\begin{table*}
\centering
\begin{tabular}{l|c|c|c|}
\cline{2-4}
\multicolumn{1}{c|}{} & \multicolumn{3}{c|}{RMSE, meters} \\
\hline
\multicolumn{1}{|c|}{Sampling type} & SYNTHIA 01 & NYU Depth & Sintel \\
\hline
\multicolumn{1}{|l|}{Uniform} & %(var03)s & %(var04)s & %(var05)s \\
\hline
\multicolumn{1}{|l|}{Regular} & %(var13)s & %(var14)s & %(var15)s \\
\hline
\multicolumn{1}{|l|}{Along gradient} & %(var23)s & %(var24)s & %(var25)s \\ \hline
\multicolumn{1}{|l|}{Gradient + uniform} & %(var33)s & %(var34)s & %(var35)s \\ \hline
\end{tabular}
\label{semidense}
\caption{Semi-dense depth interpolation results for different types of input distributions.}
\end{table*}
'''
var_dict = {'var03': a2[0][3], 'var04': a2[0][4], 'var05': a2[0][5],
'var13': a2[1][3], 'var14': a2[1][4], 'var15': a2[1][5],
'var23': a2[2][3], 'var24': a2[2][4], 'var25': a2[2][5],
'var33': a2[3][3], 'var34': a2[3][4], 'var35': a2[3][5]}
b = row_data2 % var_dict
f = open('Results/Dense/table_int_exp1.tex', 'w')
f.write(b)
f.close()
print(b)
sess.close()
