def main():
for i in range(10):
pred_disp = readPFM('output/TL' + str(i) + '.pfm')
gt = readPFM('data/Synthetic/TLD' + str(i) + '.pfm')
left_img = cv2.imread('data/Synthetic/TL' + str(i) + '.png')
loss = cal_avgerr(gt, pred_disp)
print(loss)
new_disp = weightedMedianMatlab(left_img, pred_disp, 19, 0.1, 9)
loss = cal_avgerr(gt, new_disp)
print(loss)
disp_normalized = (new_disp * 255.0).astype(np.uint8)
disp_normalized = cv2.applyColorMap(disp_normalized, cv2.COLORMAP_JET)
cv2.imshow("visualized disparity", disp_normalized)
cv2.waitKey(10000)
cv2.destroyAllWindows()
def create():
rgb_img = cv.imread(args.rgb)
height, width, _ = rgb_img.shape
if args.depth.endswith('pfm'):
depth = readPFM(args.depth)
elif args.depth.endswith('npy'):
depth = np.load(args.depth)
## create model
model = {}
vertices = []
colors = []
for w in range(width):
for h in range(height):
x, y, z = -w, -h, (depth[h, w] * (-1))
r, g, b = rgb_img[h, w]
vertices.extend([x, y, z])
colors.extend([r, g, b])
vertices = [float(i) for i in vertices]
vertices = normalize_vertices(vertices, width, height)
colors = [int(i) for i in colors]
colors = normalize_colors(colors)
model['vertexPositions'] = vertices
model['vertexFrontcolors'] = colors
model['vertexBackcolors'] = colors
## dump to file
file = open(args.save, 'w')
content = json.dumps(model)
file.write(content)
file.close()
print('Saved to file:', args.save)
def read_sample(filename_queue):
filenames = filename_queue.dequeue()
left_fn, right_fn, disp_fn = filenames[0], filenames[1], filenames[2]
left_img = tf.image.decode_image(tf.read_file(left_fn))
right_img = tf.image.decode_image(tf.read_file(right_fn))
target = tf.py_func(lambda x: readPFM(x)[0], [disp_fn], tf.float32)
return left_img, right_img, target
def main():
print('Compute error')
N = 10
imgae_dir = './data/Synthetic'
output_dir = './output/Synthetic'
err_list = []
for i in range(N):
print("loading image %d/10" % i)
gt = readPFM(os.path.join(
imgae_dir,
"TLD%d.pfm" % (i))) #os.path.join(imgae_dir, "%04d_0.png" % (i) )
disp = readPFM(os.path.join(output_dir, "SD%d.pfm" % (i)))
err = cal_avgerr(gt, disp) #GT,disp
print('avgerr: %f ' % err)
err_list.append(err)
print('Average error on synthetic data: %.2f' %
(sum(err_list) / len(err_list)))
def __init__(self, rgb_image_path=None, depth_image_path=None):
self.rgb_image = cv.imread(rgb_image_path)
self.shape = self.rgb_image.shape
if depth_image_path.endswith('pfm'):
self.depth = readPFM(depth_image_path)
elif depth_image_path.endswith('npy'):
self.depth = np.load(depth_image_path)
self.vertices = []
self.colors = []
self.process_data()
def computeDisp(Il, Ir):
h, w, ch = Il.shape
disp = np.zeros((h, w), dtype=np.int32)
# TODO: Some magic
if if_syn:
print('Synthesis')
cmd = 'python submission.py --maxdisp 192 --model stackhourglass --KITTI cv --left_datapath ' + args.input_left + ' --right_datapath ' + args.input_right + ' --output ' + "ori_" + args.output + ' --loadmodel synthesis_tune_best_for_end.tar'
print(cmd)
retcode = subprocess.call(cmd, shell=True)
print(retcode)
cmd = 'python submission.py --maxdisp 192 --model stackhourglass --KITTI cv --left_datapath ' + args.input_left + ' --right_datapath ' + args.input_right + ' --output ' + "resolu_" + args.output + ' --loadmodel aug_resolutionfinetune_146.tar'
print(cmd)
retcode = subprocess.call(cmd, shell=True)
print(retcode)
cmd = 'python submission.py --maxdisp 192 --model stackhourglass --KITTI cv --left_datapath ' + args.input_left + ' --right_datapath ' + args.input_right + ' --output ' + "color_" + args.output + ' --loadmodel aug_colorfinetune_169.tar'
print(cmd)
retcode = subprocess.call(cmd, shell=True)
print(retcode)
p1 = readPFM("ori_" + args.output)
p2 = readPFM("resolu_" + args.output)
p3 = readPFM("color_" + args.output)
final_pfm = (p1 + p2 + p3) / 3
writePFM(args.output, final_pfm)
else:
print('Real')
scale_factor = getlrdisp(Il, Ir)
print(scale_factor)
#if scale_factor in [14,56,75]:
# cmd = 'python cencus_quick.py '+ args.input_left +' '+args.input_right+' '+ args.output + ' ' +
cmd = 'python cencus_transform.py ' + args.input_left + ' ' + args.input_right + ' ' + args.output
print(cmd)
retcode = subprocess.call(cmd, shell=True)
print(retcode)
return disp
def read_sample(filename_queue, pfm_target=True):
filenames = filename_queue.dequeue()
left_fn, right_fn, disp_fn, conf_fn = filenames[0], filenames[
1], filenames[2], filenames[3]
left_img = tf.image.decode_image(tf.read_file(left_fn))
right_img = tf.image.decode_image(tf.read_file(right_fn))
if pfm_target:
target = tf.py_func(lambda x: readPFM(x)[0], [disp_fn], tf.float32)
else:
target = tf.image.decode_image(tf.read_file(disp_fn))
conf = tf.image.decode_image(tf.read_file(conf_fn))
return left_img, right_img, target, conf
def fetch_data(self):
self.left_images, self.right_images, self.ground_truths = [] , [] , []
for n in range(self.data_size):
left_image = cv2.imread(self.Ils_path[n],cv2.IMREAD_GRAYSCALE).astype(np.float32) / 255
right_image = cv2.imread(self.Irs_path[n],cv2.IMREAD_GRAYSCALE).astype(np.float32) / 255
self.ground_truths.append(readPFM(self.Gts_path[n]))
#normalization
left_image = (left_image - np.mean(left_image)) / np.std(left_image)
right_image = (right_image - np.mean(right_image)) / np.std(right_image)
self.left_images.append(left_image)
self.right_images.append(right_image)
print("fetchdata done...")
def read_sample(filename_queue,
pfm_target=True,
scaled_gt=False,
scaledConf=False):
filenames = filename_queue.dequeue()
left_fn, right_fn, disp_fn, conf_fn = filenames[0], filenames[
1], filenames[2], filenames[3]
left_img = tf.image.decode_image(tf.read_file(left_fn))
right_img = tf.image.decode_image(tf.read_file(right_fn))
if pfm_target:
target = tf.py_func(lambda x: readPFM(x)[0], [disp_fn], tf.float32)
else:
read_type = tf.uint16 if scaled_gt else tf.uint8
target = tf.image.decode_png(tf.read_file(disp_fn), dtype=read_type)
if scaled_gt:
target = tf.cast(target, tf.float32)
target = target / 256.0
read_type = tf.uint16 if scaledConf else tf.uint8
conf = tf.image.decode_png(tf.read_file(conf_fn), dtype=read_type)
if scaledConf:
conf = tf.image.convert_image_dtype(conf, tf.float32)
return left_img, right_img, target, conf
import sys
from util import readPFM, writePFM
from scipy.misc import imread
import numpy as np
import cv2
# read disparity pfm file (float32)
# the ground truth disparity maps may contain inf pixels as invalid pixels
disp = readPFM(str(sys.argv[1]))
# normalize disparity to 0.0~1.0 for visualization
max_disp = np.nanmax(disp[disp != np.inf])
min_disp = np.nanmin(disp[disp != np.inf])
disp_normalized = (disp - min_disp) / (max_disp - min_disp)
# Jet color mapping
disp_normalized = (disp_normalized * 255.0).astype(np.uint8)
disp_normalized = cv2.applyColorMap(disp_normalized, cv2.COLORMAP_JET)
# cv2.imwrite("visualized_disparity.png", disp_normalized)
cv2.imwrite("./synthe/syn7_bil2_tol.png", disp_normalized)
import sys
from util import readPFM, writePFM, cal_avgerr
import numpy as np
import cv2
# read disparity pfm file (float32)
# the ground truth disparity maps may contain inf pixels as invalid pixels
for i in range(10):
disp = readPFM('output/TL' + str(i) + '.pfm')
# normalize disparity to 0.0~1.0 for visualization
max_disp = np.nanmax(disp[disp != np.inf])
min_disp = np.nanmin(disp[disp != np.inf])
disp_normalized = (disp - min_disp) / (max_disp - min_disp)
# Jet color mapping
disp_normalized = (disp_normalized * 255.0).astype(np.uint8)
disp_normalized = cv2.applyColorMap(disp_normalized, cv2.COLORMAP_JET)
cv2.imwrite('disp_vis/TL' + str(i) + '.png', disp_normalized)
disp = readPFM('data/Synthetic/TLD' + str(i) + '.pfm')
max_disp = np.nanmax(disp[disp != np.inf])
min_disp = np.nanmin(disp[disp != np.inf])
disp_normalized = (disp - min_disp) / (max_disp - min_disp)
# Jet color mapping
disp_normalized = (disp_normalized * 255.0).astype(np.uint8)
disp_normalized = cv2.applyColorMap(disp_normalized, cv2.COLORMAP_JET)
def main():
data_dir = sys.argv[1]
output_dir = 'train-data'
os.makedirs(output_dir, exist_ok=True)
with open(os.path.join(output_dir, 'train.csv'), 'w') as f:
print('lb,rb,label', file=f)
total = 0
# Il = cv2.imread(os.path.join(data_dir, 'im0.png'))
# Ir = cv2.imread(os.path.join(data_dir, 'im1.png'))
for i in range(10):
print(i)
Il = cv2.imread(os.path.join(data_dir, f'TL{i}.png'))
Ir = cv2.imread(os.path.join(data_dir, f'TR{i}.png'))
# l_d_map = readPFM(os.path.join(data_dir, 'disp0.pfm'))
# r_d_map = readPFM(os.path.join(data_dir, 'disp1.pfm'))
l_d_map = readPFM(os.path.join(data_dir, f'TLD{i}.pfm'))
H, W, C = Il.shape
r = 10
N = 1000
count = 0
d_ops_list = [-1, 0, 1]
d_neg_list = []
d_neg_list.extend(np.arange(-21, -10))
d_neg_list.extend(np.arange(11, 22))
while True:
h = np.random.randint(r, H - r)
w = np.random.randint(r, W - r)
if l_d_map[h, w] == np.inf:
continue
d = int(l_d_map[h, w])
w_r = w - d
# if r_d_map[h, w_r] == np.inf:
# continue
# if abs(r_d_map[h, w_r] - d) > 2:
# continue
ops_w_r = w_r + d_ops_list[np.random.randint(len(d_ops_list))]
neg_w_r = w_r + d_neg_list[np.random.randint(len(d_neg_list))]
if ops_w_r < r or ops_w_r > W - r - 1 or neg_w_r < r or neg_w_r > W - r - 1:
continue
l_patch = Il[h - r:h + r + 1, w - r:w + r + 1]
ops_r_patch = Ir[h - r:h + r + 1, ops_w_r - r:ops_w_r + r + 1]
neg_r_patch = Ir[h - r:h + r + 1, neg_w_r - r:neg_w_r + r + 1]
l_name = f'{total}_l.png'
ops_r_name = f'{total}_ops_r.png'
neg_r_name = f'{total}_neg_r.png'
cv2.imwrite(os.path.join(output_dir, l_name), l_patch)
cv2.imwrite(os.path.join(output_dir, ops_r_name), ops_r_patch)
cv2.imwrite(os.path.join(output_dir, neg_r_name), neg_r_patch)
print(f'{l_name},{ops_r_name},1', file=f)
print(f'{l_name},{neg_r_name},0', file=f)
count += 1
total += 1
if count >= N:
break
from util import cal_avgerr, readPFM
files = ['./synthe/TL{}_output_noad.pfm'.format(i) for i in range(10)]
gts = ['./data/Synthetic/TLD{}.pfm'.format(i) for i in range(10)]
total = 0
for idx, (f, g) in enumerate(zip(files, gts)):
gt = readPFM(g)
result = readPFM(f)
err = cal_avgerr(gt, result)
total += err
print("{}:".format(idx), err)
print("Ave:", total / 10)
from util import cal_avgerr, readPFM
import sys
import argparse
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--GT',
default='./data/Synthetic/TLD0.pfm',
type=str,
help='Ground Truth')
parser.add_argument('--input',
default='./TL0.pfm',
type=str,
help='input disparity map')
args = parser.parse_args()
GT = readPFM(args.GT)
disp = readPFM(args.input)
print(cal_avgerr(GT, disp))
import os
import sys
import numpy as np
from util import cal_avgerr, readPFM
result_dir, gt_dir = sys.argv[1], sys.argv[2]
nums = [str(i) for i in range(10)]
with open('result.txt', 'w') as f:
for num in nums:
result = os.path.join(result_dir, 'TLD{}.pfm'.format(num))
gt = os.path.join(gt_dir, 'TLD{}.pfm'.format(num))
result = readPFM(result).reshape(196608)
gt = readPFM(gt).reshape(196608)
f.write(num + '\n')
f.write(str(cal_avgerr(gt, result)) + '\n')
#f.write('################################################################\n')
import cv2
from util import cal_avgerr, readPFM
import sys
# for finding the score, please try following
# python3 score.py data/Synthetic/TLD0.pfm result1/TL0.pfm
GT, disp = sys.argv[1], sys.argv[2]
GT = readPFM(str(GT))
disp = readPFM(str(disp))
print("average score:", cal_avgerr(GT, disp))
