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]