def get_fake_dataset(self, data_split, directory):
dataset_config = DatasetBuilder.copy_config(
DatasetBuilder.KITTI_UNITTEST)
# Overwrite config values
dataset_config.data_split = data_split
dataset_config.dataset_dir = directory
dataset = DatasetBuilder.build_kitti_dataset(dataset_config)
return dataset
def test_data_splits(self):
bad_config = DatasetBuilder.copy_config(DatasetBuilder.KITTI_UNITTEST)
# Test invalid splits
bad_config.data_split = "bad"
self.assertRaises(ValueError, KittiDataset, bad_config, 'train')
# Should be "train"
bad_config.data_split = "training"
self.assertRaises(ValueError, KittiDataset, bad_config, 'train')
# Should be "val"
bad_config.data_split = "validation"
self.assertRaises(ValueError, KittiDataset, bad_config, 'val')
# Should be "test"
bad_config.data_split = "testing"
self.assertRaises(ValueError, KittiDataset, bad_config, 'test')
# Train split
train_dataset = self.get_fake_dataset('train', self.fake_kitti_dir)
self.assertEqual(train_dataset.num_samples, 7)
# Validation split
validation_dataset = self.get_fake_dataset('val', self.fake_kitti_dir)
self.assertEqual(validation_dataset.num_samples, 6)
# Train + validation split
trainval_dataset = self.get_fake_dataset('trainval',
self.fake_kitti_dir)
self.assertEqual(trainval_dataset.num_samples, 13)
# Test split
test_dataset = self.get_fake_dataset('test', self.fake_kitti_dir)
self.assertEqual(test_dataset.num_samples, 10)
def inference(config, data_split, ckpt_indices):
train_val_test = 'test'
dataset_config = config.dataset_config
dataset_config.data_split = data_split
if data_split == 'test':
dataset_config.data_split_dir = 'testing'
dataset_config.has_kitti_labels = False
# Enable this to see the actually memory being used
config.allow_gpu_mem_growth = True
# Remove augmentation during evaluation in test mode
dataset_config.aug_config.box_jitter_type = None
# Build the dataset object
dataset = DatasetBuilder.build_kitti_dataset(dataset_config,
train_val_test=train_val_test)
# Setup the model
model_name = config.model_name
model_config = config.model_config
with tf.Graph().as_default():
if model_name == 'monopsr':
model = MonoPSRModel(model_config,
train_val_test=train_val_test,
dataset=dataset)
else:
raise ValueError('Invalid model_name')
if ckpt_indices == 'all':
model_evaluator = Evaluator(model,
config,
eval_mode='test',
skip_evaluated_checkpoints=True,
do_kitti_native_eval=False)
model_evaluator.repeated_checkpoint_run()
else:
model_evaluator = Evaluator(model,
config,
eval_mode='test',
skip_evaluated_checkpoints=False,
do_kitti_native_eval=False)
model_evaluator.run_latest_checkpoints(ckpt_indices)
def main():
##############################
# Options
##############################
dataset = DatasetBuilder.build_kitti_dataset(DatasetBuilder.KITTI_TRAINVAL)
num_jittered_boxes = 5
iou_thresh = 0.7
classes = ['Car']
sample_name = '000050'
##############################
# Get filtered labels
dataset.classes = classes
obj_labels = obj_utils.read_labels(dataset.kitti_label_dir, sample_name)
obj_labels, class_filter = obj_utils.filter_labels(obj_labels,
classes=dataset.classes)
# Image shape
bgr_image = cv2.imread(dataset.get_rgb_image_path(sample_name))
rgb_image = bgr_image[..., ::-1]
image_shape = rgb_image.shape[0:2]
# Generate jittered boxes
aug_labels = []
for label in obj_labels:
for i in range(num_jittered_boxes):
aug_label = kitti_aug.jitter_obj_boxes_2d([label], iou_thresh,
image_shape)
aug_labels.append(aug_label[0])
# Visualize boxes
fig, axes = vis_utils.plots_from_image(rgb_image, display=False)
# Draw non-augmented boxes in red
for obj in obj_labels:
vis_utils.draw_obj_as_box_2d(axes, obj, color='r')
# Draw augmented boxes in cyan
for obj in aug_labels:
vis_utils.draw_obj_as_box_2d(axes, obj, color='c', linewidth=1)
plt.show(block=True)
def main():
##############################
# Options
##############################
dataset = DatasetBuilder.build_kitti_dataset(DatasetBuilder.KITTI_TRAINVAL)
sample_name = '000050'
##############################
print('Showing instance masks for sample:', sample_name)
# Load image and instances
image = obj_utils.get_image(sample_name, dataset.image_2_dir)
instance_img = cv2.imread(dataset.instance_dir +
'/{}.png'.format(sample_name))
instance_img = instance_img[:, :, 0].astype(np.uint8)
# Get instance masks
start = time.time()
instance_masks = instance_utils.get_instance_mask_list(instance_img)
print("Time to parse instance image:", str(time.time() - start))
##########################################################
# Visualization
##########################################################
# Shown on screen
image_disp_size = (900, 300)
vis_utils.cv2_imshow('Left Image',
image,
size_wh=image_disp_size,
location_xy=(80, 0))
# Generate random colours for each instance
for i in range(instance_masks.shape[0]):
left_im_instances = instance_masks[i].astype(np.uint8) * 255
vis_utils.cv2_imshow('Instances',
left_im_instances,
size_wh=image_disp_size,
location_xy=(80, 320))
cv2.waitKey()
def setUp(self):
tf.test.TestCase.setUp(self)
test_pipeline_config_path = monopsr.root_dir() + \
'/configs/unittest_stagewise.config'
self.model_config, self.train_config, _, dataset_config = \
config_builder.get_configs_from_pipeline_file(
test_pipeline_config_path, is_training=True)
# unittest-kitti has [2, 1, 1] clusters
input_config = self.model_config.input_config
input_config.bev_depth = 5
# Generate dataset
self.dataset = DatasetBuilder.build_kitti_dataset(
DatasetBuilder.KITTI_UNITTEST,
use_defaults=False,
new_cfg=dataset_config)
def test_tf_project_pc_to_image(self):
"""Check that tf_project_pc_to_image matches numpy version"""
dataset = DatasetBuilder.build_kitti_dataset(
DatasetBuilder.KITTI_TRAINVAL)
np.random.seed(12345)
point_cloud_batch = np.random.rand(32, 3, 2304)
frame_calib = calib_utils.get_frame_calib(dataset.calib_dir, '000050')
cam_p = frame_calib.p2
exp_proj_uv = [
calib_utils.project_pc_to_image(point_cloud, cam_p)
for point_cloud in point_cloud_batch
]
tf_proj_uv = calib_utils.tf_project_pc_to_image(
point_cloud_batch, cam_p, 32)
with self.test_session() as sess:
proj_uv_out = sess.run(tf_proj_uv)
np.testing.assert_allclose(exp_proj_uv, proj_uv_out)
def setUpClass(cls):
cls.dataset = DatasetBuilder.build_kitti_dataset(
DatasetBuilder.KITTI_TRAINVAL)
def main():
##############################
# Options
##############################
point_cloud_source = 'depth_2_multiscale'
samples_to_use = None # all samples
dataset = DatasetBuilder.build_kitti_dataset(DatasetBuilder.KITTI_TRAINVAL)
out_instance_dir = 'outputs/instance_2_{}'.format(point_cloud_source)
required_classes = [
'Car',
'Pedestrian',
'Cyclist',
'Van',
'Truck',
'Person_sitting',
'Tram',
'Misc',
]
##############################
# End of Options
##############################
# Create instance folder
os.makedirs(out_instance_dir, exist_ok=True)
# Get frame ids to process
if samples_to_use is None:
samples_to_use = dataset.get_sample_names()
# Begin instance mask generation
for sample_idx, sample_name in enumerate(samples_to_use):
sys.stdout.write(
'\r{} / {} Generating {} instances for sample {}'.format(
sample_idx, dataset.num_samples - 1, point_cloud_source,
sample_name))
# Get image
image = obj_utils.get_image(sample_name, dataset.image_2_dir)
image_shape = image.shape[0:2]
# Get calibration
frame_calib = calib_utils.get_frame_calib(dataset.calib_dir,
sample_name)
# Get point cloud
if point_cloud_source.startswith('depth'):
point_cloud = obj_utils.get_depth_map_point_cloud(
sample_name, frame_calib, dataset.depth_dir)
elif point_cloud_source == 'velo':
point_cloud = obj_utils.get_lidar_point_cloud_for_cam(
sample_name, frame_calib, dataset.velo_dir, image_shape)
else:
raise ValueError('Invalid point cloud source', point_cloud_source)
# Filter according to classes
obj_labels = obj_utils.read_labels(dataset.kitti_label_dir,
sample_name)
obj_labels, _ = obj_utils.filter_labels_by_class(
obj_labels, required_classes)
# Get 2D and 3D bounding boxes from labels
gt_boxes_2d = [
box_3d_encoder.object_label_to_box_2d(obj_label)
for obj_label in obj_labels
]
gt_boxes_3d = [
box_3d_encoder.object_label_to_box_3d(obj_label)
for obj_label in obj_labels
]
instance_image = np.full(image_shape, 255, dtype=np.uint8)
# Start instance index at 0 and generate instance masks for all boxes
inst_idx = 0
for obj_label, box_2d, box_3d in zip(obj_labels, gt_boxes_2d,
gt_boxes_3d):
# Apply inflation and offset to box_3d
modified_box_3d = modify_box_3d(box_3d, obj_label)
# Get points in 3D box
box_points, mask = obj_utils.points_in_box_3d(
modified_box_3d, point_cloud.T)
# Get points in 2D box
points_in_im = calib_utils.project_pc_to_image(
box_points.T, cam_p=frame_calib.p2)
mask_2d = \
(points_in_im[0] >= box_2d[1]) & \
(points_in_im[0] <= box_2d[3]) & \
(points_in_im[1] >= box_2d[0]) & \
(points_in_im[1] <= box_2d[2])
if point_cloud_source.startswith('depth'):
mask_points_in_im = np.where(mask.reshape(image_shape))
mask_points_in_im = [
mask_points_in_im[0][mask_2d],
mask_points_in_im[1][mask_2d]
]
instance_pixels = np.asarray(
[mask_points_in_im[1], mask_points_in_im[0]])
elif point_cloud_source == 'velo':
# image_points = box_utils.project_to_image(
# box_points.T, frame.p_left).astype(np.int32)
pass
# Guarantees that indices don't exceed image dimensions
instance_pixels[0, :] = np.clip(instance_pixels[0, :], 0,
image_shape[1] - 1)
instance_pixels[1, :] = np.clip(instance_pixels[1, :], 0,
image_shape[0] - 1)
instance_image[instance_pixels[1, :],
instance_pixels[0, :]] = np.uint8(inst_idx)
inst_idx += 1
# Write image to directory
cv2.imwrite(out_instance_dir + '/{}.png'.format(sample_name),
instance_image, [cv2.IMWRITE_PNG_COMPRESSION, 1])
def main():
"""Interpolates the lidar point cloud to and saves a dense depth map of the scene.
"""
##############################
# Options
##############################
dataset = DatasetBuilder.build_kitti_dataset(DatasetBuilder.KITTI_TRAINVAL)
data_split = dataset.data_split
# Fill algorithm
fill_type = 'multiscale'
save_depth_maps = True
out_depth_map_dir = 'outputs/{}/depth_2_{}'.format(data_split, fill_type)
samples_to_use = None
##############################
# End of Options
##############################
os.makedirs(out_depth_map_dir, exist_ok=True)
# Rolling average array of times for time estimation
avg_time_arr_length = 5
last_fill_times = np.repeat([1.0], avg_time_arr_length)
last_total_times = np.repeat([1.0], avg_time_arr_length)
if samples_to_use is None:
samples_to_use = [sample.name for sample in dataset.sample_list]
for sample_idx, sample_name in enumerate(samples_to_use):
# Calculate average time with last n fill times
avg_fill_time = np.mean(last_fill_times)
avg_total_time = np.mean(last_total_times)
# Print progress
sys.stdout.write('\rProcessing {} / {}, Idx {}, Avg Fill Time: {:.5f}s, '
'Avg Time: {:.5f}s, Est Time: {:.3f}s'.format(
sample_idx, dataset.num_samples - 1, sample_name,
avg_fill_time, avg_total_time,
avg_total_time * (dataset.num_samples - sample_idx)))
sys.stdout.flush()
# Start timing
start_total_time = time.time()
# Load sample info
image = obj_utils.get_image(sample_name, dataset.image_2_dir)
image_shape = image.shape[0:2]
frame_calib = calib_utils.get_frame_calib(dataset.calib_dir, sample_name)
cam_p = frame_calib.p2
# Load point cloud
point_cloud = obj_utils.get_lidar_point_cloud(sample_name, frame_calib, dataset.velo_dir)
# Fill depth map
if fill_type == 'multiscale':
# Project point cloud to depth map
projected_depths = depth_map_utils.project_depths(point_cloud, cam_p, image_shape)
start_fill_time = time.time()
final_depth_map, _ = ip_basic.fill_in_multiscale(projected_depths)
end_fill_time = time.time()
else:
raise ValueError('Invalid fill algorithm')
# Save depth maps
if save_depth_maps:
out_depth_map_path = out_depth_map_dir + '/{}.png'.format(sample_name)
depth_map_utils.save_depth_map(out_depth_map_path, final_depth_map)
# Stop timing
end_total_time = time.time()
# Update fill times
last_fill_times = np.roll(last_fill_times, -1)
last_fill_times[-1] = end_fill_time - start_fill_time
# Update total times
last_total_times = np.roll(last_total_times, -1)
last_total_times[-1] = end_total_time - start_total_time
def setUpClass(cls):
cls.fake_kitti_dir = tests.test_path() + '/datasets/Kitti/object'
cls.dataset = DatasetBuilder.build_kitti_dataset(
DatasetBuilder.KITTI_UNITTEST)