def _load_image(self, files):
left_file_name = files[0]
right_file_name = files[1]
gt_file_name = files[2]
left_image = read_image_from_disc(left_file_name)
right_image = read_image_from_disc(right_file_name)
if self._usePfm:
gt_image = tf.py_func(lambda x: readPFM(x)[0], [gt_file_name],
tf.float32)
gt_image.set_shape([None, None, 1])
else:
read_type = tf.uint16 if self._double_prec_gt else tf.uint8
gt_image = read_image_from_disc(gt_file_name,
shape=[None, None, 1],
dtype=read_type)
gt_image = tf.cast(gt_image, tf.float32)
if self._double_prec_gt:
gt_image = gt_image / 256.0
#crop gt to fit with image (SGM add some paddings who know why...)
gt_image = gt_image[:, :tf.shape(left_image)[1], :]
if self._is_training:
left_image, right_image, gt_image = preprocessing.random_crop(
self._crop_shape, [left_image, right_image, gt_image])
else:
(left_image, right_image, gt_image) = [
tf.image.resize_image_with_crop_or_pad(x, self._crop_shape[0],
self._crop_shape[1])
for x in [left_image, right_image, gt_image]
]
if self._augment:
left_image, right_image = preprocessing.augment(
left_image, right_image)
return [left_image, right_image, gt_image]
def _build_input_pipeline(self):
left_files, right_files, gt_files, _ = read_list_file(self._path_file)
self._couples = [[l, r, gt]
for l, r, gt in zip(left_files, right_files, gt_files)
]
#flags
self._usePfm = gt_files[0].endswith('pfm') or gt_files[0].endswith(
'PFM')
if not self._usePfm:
gg = cv2.imread(gt_files[0], -1)
self._double_prec_gt = (gg.dtype == np.uint16)
input_queue = tf.train.input_producer(self._couples,
num_epochs=self._num_epochs,
shuffle=self._shuffle)
files = input_queue.dequeue()
left_file_name = files[0]
right_file_name = files[1]
gt_file_name = files[2]
left_image = read_image_from_disc(left_file_name)
right_image = read_image_from_disc(right_file_name)
if self._usePfm:
gt_image = tf.py_func(lambda x: readPFM(x)[0], [gt_file_name],
tf.float32)
gt_image.set_shape([None, None, 1])
else:
read_type = tf.uint16 if self._double_prec_gt else tf.uint8
gt_image = read_image_from_disc(gt_file_name,
shape=[None, None, 1],
dtype=read_type)
gt_image = tf.cast(gt_image, tf.float32)
if self._double_prec_gt:
gt_image = gt_image / 256.0
#crop gt to fit with image (SGM add some paddings who know why...)
gt_image = gt_image[:, :tf.shape(left_image)[1], :]
if self._is_training:
left_image, right_image, gt_image = preprocessing.random_crop(
self._crop_shape, [left_image, right_image, gt_image])
else:
(left_image, right_image, gt_image) = [
tf.image.resize_image_with_crop_or_pad(x, self._crop_shape[0],
self._crop_shape[1])
for x in [left_image, right_image, gt_image]
]
if self._augment:
left_image, right_image = preprocessing.augment(
left_image, right_image)
tt = 4 if self._shuffle else 1
self._left_batch, self._right_batch, self._gt_batch = tf.train.batch(
[left_image, right_image, gt_image],
self._batch_size,
capacity=self._batch_size * 20,
num_threads=tt)
def _load_sample(self, files):
left_file_name = files[0]
right_file_name = files[1]
gt_file_name = files[2]
#read rgb images
left_image = read_image_from_disc(left_file_name)
right_image = read_image_from_disc(right_file_name)
#read gt
if self._usePfm:
gt_image = tf.py_func(lambda x: readPFM(x)[0], [gt_file_name],
tf.float32)
gt_image.set_shape([None, None, 1])
else:
read_type = tf.uint16 if self._double_prec_gt else tf.uint8
gt_image = read_image_from_disc(gt_file_name,
shape=[None, None, 1],
dtype=read_type)
gt_image = tf.cast(gt_image, tf.float32)
if self._double_prec_gt:
gt_image = gt_image / 256.0
#crop gt to fit with image (SGM adds some paddings who know why...)
gt_image = gt_image[:, :tf.shape(left_image)[1], :]
if self._resize_shape[0] is not None:
scale_factor = tf.cast(tf.shape(gt_image_left)[1],
tf.float32) / float(self._resize_shape[1])
left_image = preprocessing.rescale_image(left_image,
self._resize_shape)
right_image = preprocessing.rescale_image(right_image,
self._resize_shape)
gt_image = tf.image.resize_nearest_neighbor(
tf.expand_dims(gt_image, axis=0),
self._resize_shape)[0] / scale_factor
if self._crop_shape[0] is not None:
if self._is_training:
left_image, right_image, gt_image = preprocessing.random_crop(
self._crop_shape, [left_image, right_image, gt_image])
else:
(left_image, right_image, gt_image) = [
tf.image.resize_image_with_crop_or_pad(
x, self._crop_shape[0], self._crop_shape[1])
for x in [left_image, right_image, gt_image]
]
if self._augment:
left_image, right_image = preprocessing.augment(
left_image, right_image)
return [left_image, right_image, gt_image]
def _load_task(self, files):
"""
Load all the image and return them as three lists, [left_files], [right_files], [gt_files]
"""
#from 3xk to kx3
left_files = files[0]
right_files = files[1]
gt_files = files[2]
#read images
left_task_samples = tf.map_fn(
read_image_from_disc,
left_files,
dtype=tf.float32,
parallel_iterations=self._sequence_length)
left_task_samples.set_shape([self._sequence_length, None, None, 3])
right_task_samples = tf.map_fn(
read_image_from_disc,
right_files,
dtype=tf.float32,
parallel_iterations=self._sequence_length)
right_task_samples.set_shape([self._sequence_length, None, None, 3])
gt_task_samples = tf.map_fn(self._decode_gt,
gt_files,
dtype=tf.float32,
parallel_iterations=self._sequence_length)
gt_task_samples.set_shape([self._sequence_length, None, None, 1])
#alligned image resize
if self._resize_shape[0] is not None:
scale_factor = tf.cast(
tf.shape(left_task_samples)[1] // self._resize_shape[1],
tf.float32)
left_task_samples = preprocessing.rescale_image(
left_task_samples, self._resize_shape)
right_task_samples = preprocessing.rescale_image(
right_task_samples, self._resize_shape)
gt_task_samples = tf.image.resize_nearest_neighbor(
gt_task_samples, self._resize_shape) / scale_factor
#alligned random crop
if self._crop_shape[0] is not None:
left_task_samples, right_task_samples, gt_task_samples = preprocessing.random_crop(
self._crop_shape,
[left_task_samples, right_task_samples, gt_task_samples])
#augmentation
if self._augment:
left_task_samples, right_task_samples = preprocessing.augment(
left_task_samples, right_task_samples)
return [left_task_samples, right_task_samples, gt_task_samples]
def _load_image_with_proxies(self, files):
left_file_name = files[0]
right_file_name = files[1]
gt_file_name = files[2]
proxy_file_name = files[3]
left_image = read_image_from_disc(left_file_name)
right_image = read_image_from_disc(right_file_name)
if self._usePfm:
gt_image = tf.py_func(lambda x: readPFM(x)[0], [gt_file_name],
tf.float32)
gt_image.set_shape([None, None, 1])
else:
read_type = tf.uint16 if self._double_prec_gt else tf.uint8
gt_image = read_image_from_disc(gt_file_name,
shape=[None, None, 1],
dtype=read_type)
gt_image = tf.cast(gt_image, tf.float32)
if self._double_prec_gt:
gt_image = gt_image / 256.0
gt_image = gt_image[:, :tf.shape(left_image)[1], :]
px_read_type = tf.uint16 if self._double_prec_px else tf.uint8
proxy_image = read_image_from_disc(proxy_file_name,
shape=[None, None, 1],
dtype=px_read_type)
proxy_image = tf.cast(proxy_image, tf.float32)
if self._double_prec_px:
proxy_image = proxy_image / 256.0
real_width = tf.shape(left_image)[1]
proxy_image = proxy_image[:, :tf.shape(left_image)[1], :]
if self._is_training:
left_image, right_image, gt_image = preprocessing.random_crop(
self._crop_shape, [left_image, right_image, gt_image])
else:
(left_image, right_image, gt_image, proxy_image) = [
tf.image.resize_image_with_crop_or_pad(x, self._crop_shape[0],
self._crop_shape[1])
for x in [left_image, right_image, gt_image, proxy_image]
]
if self._augment:
left_image, right_image = preprocessing.augment(
left_image, right_image)
return [left_image, right_image, gt_image, proxy_image, real_width]