def run_panoptic_orient_script_with_05_iou(checkpoint_name, score_threshold,
global_step):
"""Runs the panoptic native code script."""
eval_script_dir = pplp.root_dir() + '/data/outputs/' + \
checkpoint_name + '/predictions'
make_script = eval_script_dir + \
'/panoptic_pplp_eval/run_eval_orient_05_iou.sh'
script_folder = eval_script_dir + \
'/panoptic_pplp_eval/'
results_dir = pplp.top_dir() + '/scripts/offline_eval/results_orient_05_iou/'
print('--------------- run_panoptic_orient_script_with_05_iou(checkpoint_name, score_threshold, global_step) -----------')
print('make_script = ', make_script)
print('script_folder = ', script_folder)
print('score_threshold = ', score_threshold)
print('global_step = ', global_step)
print('checkpoint_name = ', checkpoint_name)
print('results_dir = ', results_dir)
# Round this because protobuf encodes default values as full decimal
score_threshold = round(score_threshold, 3)
subprocess.call([make_script, script_folder,
str(score_threshold),
str(global_step),
str(checkpoint_name),
str(results_dir)])
def copy_kitti_native_code(checkpoint_name):
"""Copies and compiles kitti native code.
It also creates neccessary directories for storing the results
of the kitti native evaluation code.
"""
pplp_root_dir = pplp.root_dir()
kitti_native_code_copy = pplp_root_dir + '/data/outputs/' + \
checkpoint_name + '/predictions/kitti_native_eval/'
# Only copy if the code has not been already copied over
if not os.path.exists(kitti_native_code_copy):
os.makedirs(kitti_native_code_copy)
original_kitti_native_code = pplp.top_dir() + \
'/scripts/offline_eval/kitti_native_eval/'
predictions_dir = pplp_root_dir + '/data/outputs/' + \
checkpoint_name + '/predictions/'
# create dir for it first
dir_util.copy_tree(original_kitti_native_code, kitti_native_code_copy)
# run the script to compile the c++ code
script_folder = predictions_dir + \
'/kitti_native_eval/'
make_script = script_folder + 'run_make.sh'
subprocess.call([make_script, script_folder])
# Set up the results folders if they don't exist
results_dir = pplp.top_dir() + '/scripts/offline_eval/results'
results_05_dir = pplp.top_dir() + '/scripts/offline_eval/results_05_iou'
if not os.path.exists(results_dir):
os.makedirs(results_dir)
if not os.path.exists(results_05_dir):
os.makedirs(results_05_dir)
def test_get_clusters(self):
# classes = ['Car', 'Pedestrian', 'Cyclist']
num_clusters = [2, 1, 1]
label_cluster_utils = LabelClusterUtils(self.dataset)
clusters, std_devs = label_cluster_utils.get_clusters()
# Check that correct number of clusters are returned
clusters_per_class = [len(cls_clusters) for cls_clusters in clusters]
std_devs_per_class = [len(cls_std_devs) for cls_std_devs in std_devs]
self.assertEqual(clusters_per_class, num_clusters)
self.assertEqual(std_devs_per_class, num_clusters)
# Check that text files were saved
txt_folder_exists = os.path.isdir(
pplp.root_dir() + "/data/label_clusters/unittest-kitti")
self.assertTrue(txt_folder_exists)
# Calling get_clusters again should read from files
read_clusters, read_std_devs = label_cluster_utils.get_clusters()
# Check that read values are the same as generated ones
np.testing.assert_allclose(np.vstack(clusters),
np.vstack(read_clusters))
np.testing.assert_allclose(np.vstack(std_devs),
np.vstack(read_std_devs))
def main():
"""Generates anchors info which is used for mini batch sampling.
This code only generate mini batches for the CMU Panoptic dataset.
"""
panoptic_dataset_config_path = pplp.root_dir() + \
'/configs/mb_preprocessing/rpn_panoptic_3d.config'
##############################
# Options
##############################
# Serial vs parallel processing
in_parallel = False # Change it back to True after debugging
process_ped = True # Pedestrians , default: False
# Number of child processes to fork, samples will
# be divided evenly amongst the processes (in_parallel must be True)
num_ped_children = 8
##############################
# Dataset setup
##############################
if process_ped:
ped_dataset = DatasetBuilder.load_dataset_from_config(
panoptic_dataset_config_path)
##############################
# Serial Processing
##############################
if not in_parallel:
if process_ped:
do_preprocessing(ped_dataset, None)
print('All Done (Serial)')
##############################
# Parallel Processing
##############################
else:
# List of all child pids to wait on
all_child_pids = []
# Pedestrians
if process_ped:
ped_indices_split = split_indices(ped_dataset, num_ped_children)
split_work(all_child_pids, ped_dataset, ped_indices_split,
num_ped_children)
# Wait to child processes to finish
print('num children:', len(all_child_pids))
for i, child_pid in enumerate(all_child_pids):
os.waitpid(child_pid, 0)
print('All Done (Parallel)')
def setUpClass(cls):
pipeline_config = pipeline_pb2.NetworkPipelineConfig()
dataset_config = pipeline_config.dataset_config
config_path = pplp.root_dir() + '/configs/unittest_model.config'
cls.model_config = config_build.get_model_config_from_file(config_path)
dataset_config.MergeFrom(DatasetBuilder.KITTI_UNITTEST)
cls.dataset = DatasetBuilder.build_kitti_dataset(dataset_config)
def __init__(self, dataset):
self._dataset = dataset
self.cluster_split = dataset.cluster_split
self.data_dir = pplp.root_dir() + "/data/label_clusters"
self.clusters = []
self.std_devs = []
def main(_):
parser = argparse.ArgumentParser()
# Example usage
# --checkpoint_name='avod_cars_example'
# --data_split='test'
# --ckpt_indices=50 100 112
# Optional arg:
# --device=0
parser.add_argument('--checkpoint_name',
type=str,
dest='checkpoint_name',
required=True,
help='Checkpoint name must be specified as a str\
and must match the experiment config file name.')
parser.add_argument('--data_split',
type=str,
dest='data_split',
required=True,
help='Data split must be specified e.g. val or test')
parser.add_argument(
'--ckpt_indices',
type=int,
nargs='+',
dest='ckpt_indices',
required=True,
help='Checkpoint indices must be a set of \
integers with space in between -> 0 10 20 etc')
parser.add_argument('--device',
type=str,
dest='device',
default='0',
help='CUDA device id')
args = parser.parse_args()
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
experiment_config = args.checkpoint_name + '.config'
# Read the config from the experiment folder
experiment_config_path = pplp.root_dir() + '/data/outputs/' +\
args.checkpoint_name + '/' + experiment_config
model_config, _, eval_config, dataset_config = \
config_builder.get_configs_from_pipeline_file(
experiment_config_path, is_training=False)
os.environ['CUDA_VISIBLE_DEVICES'] = args.device
inference(model_config, eval_config,
dataset_config, args.data_split,
args.ckpt_indices)
def setUp(self):
tf.test.TestCase.setUp(self)
test_pipeline_config_path = pplp.root_dir() + \
'/configs/unittest_pipeline.config'
self.model_config, self.train_config, _, dataset_config = \
config_builder.get_configs_from_pipeline_file(
test_pipeline_config_path, is_training=True)
# Generate dataset
self.dataset = DatasetBuilder.build_kitti_dataset(
DatasetBuilder.KITTI_UNITTEST,
use_defaults=False,
new_cfg=dataset_config)
def main(_):
parser = argparse.ArgumentParser()
default_pipeline_config_path = pplp.root_dir() + \
'/configs/orientation_pedestrian_panoptic.config'
parser.add_argument('--pipeline_config',
type=str,
dest='pipeline_config_path',
default=default_pipeline_config_path,
help='Path to the pipeline config')
parser.add_argument('--data_split',
type=str,
dest='data_split',
default='val',
help='Data split for evaluation')
parser.add_argument('--device',
type=str,
dest='device',
default='0',
help='CUDA device id')
args = parser.parse_args()
# Parse pipeline config
model_config, _, eval_config, dataset_config = \
config_builder.get_configs_from_pipeline_file(
args.pipeline_config_path,
is_training=False)
# Overwrite data split
dataset_config.data_split = args.data_split
# Overwrite eval_config if data_split is 'test'
if args.data_split.startswith('test'):
eval_config.eval_mode = 'test'
# Set CUDA device id
os.environ['CUDA_VISIBLE_DEVICES'] = args.device
print('model_config = ', model_config)
print('eval_config = ', eval_config)
print('dataset_config = ', dataset_config)
evaluate(model_config, eval_config, dataset_config)
def main(_):
parser = argparse.ArgumentParser()
# Defaults
default_pipeline_config_path = pplp.root_dir() + \
'/configs/avod_pedestrian_panoptic.config'
default_data_split = 'train'
default_device = '1'
parser.add_argument('--pipeline_config',
type=str,
dest='pipeline_config_path',
default=default_pipeline_config_path,
help='Path to the pipeline config')
parser.add_argument('--data_split',
type=str,
dest='data_split',
default=default_data_split,
help='Data split for training')
parser.add_argument('--device',
type=str,
dest='device',
default=default_device,
help='CUDA device id')
args = parser.parse_args()
# Parse pipeline config
model_config, train_config, _, dataset_config = \
config_builder.get_configs_from_pipeline_file(
args.pipeline_config_path, is_training=True)
# Overwrite data split
dataset_config.data_split = args.data_split
# Set CUDA device id
os.environ['CUDA_VISIBLE_DEVICES'] = args.device
train(model_config, train_config, dataset_config)
def run_kitti_native_script(checkpoint_name, score_threshold, global_step):
"""Runs the kitti native code script."""
eval_script_dir = pplp.root_dir() + '/data/outputs/' + \
checkpoint_name + '/predictions'
make_script = eval_script_dir + \
'/kitti_native_eval/run_eval.sh'
script_folder = eval_script_dir + \
'/kitti_native_eval/'
results_dir = pplp.top_dir() + '/scripts/offline_eval/results/'
# Round this because protobuf encodes default values as full decimal
score_threshold = round(score_threshold, 3)
subprocess.call([
make_script, script_folder,
str(score_threshold),
str(global_step),
str(checkpoint_name),
str(results_dir)
])
def main():
"""This demo shows OrientNet predictions on 2D image space.
Given certain thresholds for predictions, it selects and draws the
groundtruth bounding boxes on the image sample. It goes through the entire
prediction samples for the given dataset split.
"""
dataset_config = DatasetBuilder.copy_config(DatasetBuilder.PANOPTIC_VAL)
##############################
# Options
##############################
dataset_config = DatasetBuilder.merge_defaults(dataset_config)
dataset_config.data_split = 'val'
# fig_size = (10, 6.1)
fig_size = (12, 23) # The size of final picture as a whole.
rpn_score_threshold = 0.00
orientnet_score_threshold = 0.30
gt_classes = ['Pedestrian']
# Overwrite this to select a specific checkpoint
print('!!!Please make sure your settings are all correct!!!!!')
global_step = 298261 # None
checkpoint_name = 'orientation_pedestrian_panoptic'
# Drawing Toggles
draw_proposals_separate = False
draw_overlaid = False # To draw both proposal and predcition bounding boxes
draw_predictions_separate = True
# Show orientation for both GT and proposals/predictions
draw_orientations_on_prop = False # Set it to false would be OK, since all the orietations of proposals are poiting to the 0 angle.
draw_orientations_on_pred = True
# Draw 2D bounding boxes
draw_projected_2d_boxes = True
# Draw BEV bounding boxes
draw_bev_map = False
# Draw pointclouds
draw_point_cloud = True
point_cloud_source = 'lidar'
slices_config = \
"""
slices {
height_lo: -5 # -0.2
height_hi: 2 # 2.3
num_slices: 1 # 5
}
"""
print('slices_config = ', slices_config)
text_format.Merge(slices_config,
dataset_config.panoptic_utils_config.bev_generator)
# Save images for samples with no detections
save_empty_images = False
draw_proposals_bev = True
draw_proposals_2d_box = False
draw_proposals_3d_box = True
draw_proposals_score = True
draw_proposals_iou = True
draw_prediction_score = True
draw_prediction_iou = True
##############################
# End of Options
##############################
# Get the dataset
dataset = DatasetBuilder.build_panoptic_dataset(dataset_config,
use_defaults=False)
# Setup Paths
predictions_dir = pplp.root_dir() + \
'/data/outputs/' + checkpoint_name + '/predictions'
proposals_and_scores_dir = predictions_dir + \
'/proposals_and_scores/' + dataset.data_split
predictions_and_scores_dir = predictions_dir + \
'/final_predictions_and_scores/' + dataset.data_split
# Output images directories
output_dir_base = predictions_dir + '/images_2d'
# Get checkpoint step
steps = os.listdir(proposals_and_scores_dir)
steps.sort(key=int)
print('Available steps: {}'.format(steps))
# Use latest checkpoint if no index provided
if global_step is None:
global_step = steps[-1]
if draw_proposals_separate:
prop_out_dir = output_dir_base + '/proposals/{}/{}/{}'.format(
dataset.data_split, global_step, rpn_score_threshold)
if not os.path.exists(prop_out_dir):
os.makedirs(prop_out_dir)
print('Proposal images saved to:', prop_out_dir)
if draw_overlaid:
overlaid_out_dir = output_dir_base + '/overlaid/{}/{}/{}'.format(
dataset.data_split, global_step, orientnet_score_threshold)
if not os.path.exists(overlaid_out_dir):
os.makedirs(overlaid_out_dir)
print('Overlaid images saved to:', overlaid_out_dir)
if draw_predictions_separate:
pred_out_dir = output_dir_base + '/predictions/{}/{}/{}'.format(
dataset.data_split, global_step, orientnet_score_threshold)
if not os.path.exists(pred_out_dir):
os.makedirs(pred_out_dir)
print('Prediction images saved to:', pred_out_dir)
# Rolling average array of times for time estimation
avg_time_arr_length = 10
last_times = np.repeat(time.time(), avg_time_arr_length) + \
np.arange(avg_time_arr_length)
# for sample_idx in [100]:
# print('Hack the number!!!!!')
for sample_idx in range(dataset.num_samples):
print('\nStart sample #', sample_idx + 1)
# Estimate time remaining with 5 slowest times
start_time = time.time()
last_times = np.roll(last_times, -1)
last_times[-1] = start_time
avg_time = np.mean(np.sort(np.diff(last_times))[-5:])
samples_remaining = dataset.num_samples - sample_idx
est_time_left = avg_time * samples_remaining
# Print progress and time remaining estimate
sys.stdout.write('\rSaving {} / {}, Avg Time: {:.3f}s, '
'Time Remaining: {:.2f}s \n'.format(
sample_idx + 1, dataset.num_samples, avg_time,
est_time_left))
sys.stdout.flush()
sample_name = dataset.sample_names[sample_idx]
img_idx = int(sample_name)
##############################
# Proposals
##############################
if draw_proposals_separate or draw_overlaid:
# Load proposals from files
proposals_file_path = proposals_and_scores_dir + \
"/{}/{}.txt".format(global_step, sample_name)
print('proposals_file_path = ', proposals_file_path)
if not os.path.exists(proposals_file_path):
print(proposals_file_path, 'does not exist!')
print('Sample {}: No proposals, skipping'.format(sample_name))
continue
print('Sample {}: Drawing proposals'.format(sample_name))
proposals_and_scores = np.loadtxt(proposals_file_path)
# change 1D array in to 2D array even if it has only one row.
if len(proposals_and_scores.shape) == 1:
proposals_and_scores.shape = (1, -1)
# proposals_and_scores, 1~7th colunms are the boxes_3d,
# the 8th colunm is the score.
proposal_boxes_3d = proposals_and_scores[:, 0:7]
proposal_scores = proposals_and_scores[:, 7]
# Apply score mask to proposals
print('rpn_score_threshold = ', rpn_score_threshold)
score_mask = proposal_scores >= rpn_score_threshold
proposal_boxes_3d = proposal_boxes_3d[score_mask]
proposal_scores = proposal_scores[score_mask]
print('There are ', len(proposal_scores), 'proposals left. ')
proposal_objs = \
[box_3d_panoptic_encoder.box_3d_to_object_label(proposal,
obj_type='Proposal')
for proposal in proposal_boxes_3d]
##############################
# Predictions
##############################
if draw_predictions_separate or draw_overlaid:
predictions_file_path = predictions_and_scores_dir + \
"/{}/{}.txt".format(global_step,
sample_name)
if not os.path.exists(predictions_file_path):
print('predictions_file_path NOT EXIST: ',
predictions_file_path)
continue
# Load predictions from files
predictions_and_scores = np.loadtxt(
predictions_and_scores_dir +
"/{}/{}.txt".format(global_step, sample_name))
# change 1D array in to 2D array even if it has only one row.
if len(predictions_and_scores.shape) == 1:
predictions_and_scores.shape = (1, -1)
# print('predictions_and_scores = ', predictions_and_scores)
prediction_boxes_3d = predictions_and_scores[:, 0:7]
prediction_scores = predictions_and_scores[:, 7]
# print('prediction_scores = ', prediction_scores)
prediction_class_indices = predictions_and_scores[:, 8]
# process predictions only if we have any predictions left after
# masking
if len(prediction_boxes_3d) > 0:
# Apply score mask
avod_score_mask = prediction_scores >= orientnet_score_threshold
prediction_boxes_3d = prediction_boxes_3d[avod_score_mask]
print('orientnet_score_threshold = ',
orientnet_score_threshold)
print('There are ', len(prediction_boxes_3d),
' predictions left.')
prediction_scores = prediction_scores[avod_score_mask]
prediction_class_indices = \
prediction_class_indices[avod_score_mask]
# # Swap l, w for predictions where w > l
# swapped_indices = \
# prediction_boxes_3d[:, 4] > prediction_boxes_3d[:, 3]
# prediction_boxes_3d = np.copy(prediction_boxes_3d)
# prediction_boxes_3d[swapped_indices, 3] = \
# prediction_boxes_3d[swapped_indices, 4]
# prediction_boxes_3d[swapped_indices, 4] = \
# prediction_boxes_3d[swapped_indices, 3]
##############################
# Ground Truth
##############################
# Get ground truth labels
if dataset.has_labels:
print('dataset.label_dir = ', dataset.label_dir)
print('img_idx = ', img_idx)
gt_objects = obj_panoptic_utils.read_labels(
dataset.label_dir, img_idx)
# for obj in gt_objects:
# print('obj.x1 = ', obj.x1)
else:
gt_objects = []
# Filter objects to desired difficulty
filtered_gt_objs = dataset.panoptic_utils.filter_labels(
gt_objects, classes=gt_classes)
# if sample_idx == 100:
# for obj in filtered_gt_objs:
# if obj.t[0]>1:
# # print('obj.x1 = ', obj.x1)
# # print('obj.y1 = ', obj.y1)
# # print('obj.x2 = ', obj.x2)
# # print('obj.y2 = ', obj.y2)
# print('obj.t = ', obj.t)
# print('obj.w = ', obj.w)
# print('obj.h = ', obj.h)
# print('obj.l = ', obj.l)
# # print('filtered_gt_objs.x1 = ', filtered_gt_objs.x1)
# # print('filtered_gt_objs.x2 = ', filtered_gt_objs.x2)
# # print('filtered_gt_objs.y1 = ', filtered_gt_objs.y1)
# # print('filtered_gt_objs.y2 = ', filtered_gt_objs.y2)
boxes2d, _, _ = obj_panoptic_utils.build_bbs_from_objects(
filtered_gt_objs, class_needed=gt_classes)
image_path = dataset.get_rgb_image_path(sample_name)
image = Image.open(image_path)
image_size = image.size
# Read the stereo calibration matrix for visualization
stereo_calib = calib_panoptic_utils.read_calibration(
dataset.calib_dir, img_idx)
calib_p2 = stereo_calib.HD_11
distortion = stereo_calib.Kd_11
##############################
# Reformat and prepare to draw
##############################
# To get the BEV occupancy map, we need to find the ground plane first.
panoptic_utils = dataset.panoptic_utils
ground_plane = panoptic_utils.get_ground_plane(sample_name)
image_shape = [image.size[1], image.size[0]]
point_cloud = panoptic_utils.get_point_cloud('lidar', img_idx,
image_shape)
bev_maps = panoptic_utils.create_bev_maps(point_cloud, ground_plane)
bev_img = np.array(
bev_maps['occupancy_maps'], dtype=np.int
) # Remember, the original occupancy grid format is int.
bev_img = np.resize(
bev_img, (bev_img.shape[1], bev_img.shape[2])) # [height, width]
if not draw_bev_map:
bev_img = np.zeros((bev_img.shape[1], bev_img.shape[2]),
dtype=np.float)
if draw_proposals_separate or draw_overlaid:
proposals_as_anchors = box_3d_panoptic_encoder.box_3d_to_anchor(
proposal_boxes_3d)
proposal_boxes, _ = anchor_panoptic_projector.project_to_image_space(
proposals_as_anchors,
calib_p2,
image_size,
distortion=distortion)
num_of_proposals = proposal_boxes_3d.shape[0]
prop_fig, prop_bev_axes, prop_2d_axes, prop_3d_axes = \
vis_panoptic_utils.visualization(dataset.rgb_image_dir,
img_idx,
bev_img,
display=False,
fig_size=fig_size)
draw_proposals(filtered_gt_objs,
calib_p2,
num_of_proposals,
proposal_objs,
proposal_scores,
proposal_boxes,
prop_2d_axes,
prop_3d_axes,
prop_bev_axes,
panoptic_utils.area_extents,
bev_img.shape,
draw_proposals_bev,
draw_proposals_2d_box,
draw_proposals_3d_box,
draw_proposals_score,
draw_proposals_iou,
draw_orientations_on_prop,
distortion=distortion)
if draw_point_cloud:
# First,get pointclouds. Now pointclouds are in camera coordinates.
panoptic_utils = dataset.panoptic_utils
image_shape = [image_size[1], image_size[0]]
point_cloud = panoptic_utils.get_point_cloud(
point_cloud_source, img_idx, image_shape)
# print('point_cloud =', point_cloud)
# Now point_cloud is a 4XN array, in Lidar frame, but only
# includes those points that can be seen on the image
# Filter the useful pointclouds from all points
# In order to do that, we need to find the ground plane first.
ground_plane = panoptic_utils.get_ground_plane(sample_name)
filtered_points = panoptic_utils.filter_bev_points(
point_cloud, ground_plane)
# if len(filtered_points) > 0:
# print('point_cloud =', point_cloud)
# print('filtered_points =', filtered_points)
# Now, filtered_points is transposed, so filtered_points should
# be Nx4
# Project the filtered pointclouds on 2D image. Now filtered
# pointclouds are already in camera coordinates.
point_2d = obj_panoptic_utils.project_points_on_2D_image(
img_idx, dataset.calib_dir, image_size, filtered_points)
draw_points(prop_2d_axes, point_2d, 'red', pt_size=4)
# TODO: Project the filtered pointclouds on BEV image. Now filtered
# pointclouds are already in camera coordinates.
# point_bev = obj_panoptic_utils.project_points_on_BEV_image(img_idx,
# dataset.calib_dir,
# image_size,
# filtered_points)
# draw_points(prop_bev_axes, point_bev, 'red', pt_size=4)
if draw_proposals_separate:
# Save just the proposals
filename = prop_out_dir + '/' + sample_name + '.jpg'
print('Draw proposals_separate: ', filename)
# Now add the legends
# prop_bev_axes.legend(loc='best', shadow=True, fontsize=20)
# prop_2d_axes.legend(loc='best', shadow=True, fontsize=20)
# prop_3d_axes.legend(loc='upper right', shadow=True, fontsize=20)
plt.savefig(filename)
if not draw_overlaid:
plt.close(prop_fig)
if draw_overlaid or draw_predictions_separate:
# print('prediction_boxes_3d = ', prediction_boxes_3d)
if len(prediction_boxes_3d) > 0:
# Project the 3D box predictions to image space
image_filter = []
final_boxes_2d = []
for i in range(len(prediction_boxes_3d)):
box_3d = prediction_boxes_3d[i, 0:7]
img_box = box_3d_panoptic_projector.project_to_image_space(
box_3d,
calib_p2,
truncate=True,
image_size=image_size,
discard_before_truncation=False,
distortion=distortion)
if img_box is not None:
image_filter.append(True)
final_boxes_2d.append(img_box)
else:
image_filter.append(False)
final_boxes_2d = np.asarray(final_boxes_2d)
final_prediction_boxes_3d = prediction_boxes_3d[image_filter]
final_scores = prediction_scores[image_filter]
final_class_indices = prediction_class_indices[image_filter]
num_of_predictions = final_boxes_2d.shape[0]
# Convert to objs
final_prediction_objs = \
[box_3d_panoptic_encoder.box_3d_to_object_label(
prediction, obj_type='Prediction')
for prediction in final_prediction_boxes_3d]
for (obj, score) in zip(final_prediction_objs, final_scores):
obj.score = score
else:
if save_empty_images:
pred_fig, pred_bev_axes, pred_2d_axes, pred_3d_axes = \
vis_panoptic_utils.visualization(dataset.rgb_image_dir,
img_idx,
display=False,
fig_size=fig_size)
filename = pred_out_dir + '/' + sample_name + '.jpg'
plt.savefig(filename)
print('Draw empty_images: ', filename)
plt.close(pred_fig)
continue
if draw_overlaid:
# Overlay prediction boxes on image
draw_predictions(filtered_gt_objs,
calib_p2,
num_of_predictions,
final_prediction_objs,
final_class_indices,
final_boxes_2d,
prop_2d_axes,
prop_3d_axes,
prop_bev_axes,
panoptic_utils.area_extents,
bev_img.shape,
draw_prediction_score,
draw_prediction_iou,
gt_classes,
draw_orientations_on_pred,
distortion=distortion)
filename = overlaid_out_dir + '/' + sample_name + '.jpg'
# Now add the legends
# prop_bev_axes.legend(loc='best', shadow=True, fontsize=20)
# prop_2d_axes.legend(loc='best', shadow=True, fontsize=20)
# prop_3d_axes.legend(loc='upper right', shadow=True, fontsize=20)
plt.savefig(filename)
print('Draw overlaid: ', filename)
plt.close(prop_fig)
if draw_predictions_separate:
# Now only draw prediction boxes on images
# on a new figure handler
if draw_projected_2d_boxes:
pred_fig, pred_bev_axes, pred_2d_axes, pred_3d_axes = \
vis_panoptic_utils.visualization(dataset.rgb_image_dir,
img_idx,
bev_img,
display=False,
fig_size=fig_size)
draw_predictions(filtered_gt_objs,
calib_p2,
num_of_predictions,
final_prediction_objs,
final_class_indices,
final_boxes_2d,
pred_2d_axes,
pred_3d_axes,
pred_bev_axes,
panoptic_utils.area_extents,
bev_img.shape,
draw_prediction_score,
draw_prediction_iou,
gt_classes,
draw_orientations_on_pred,
distortion=distortion)
# Now add the legends
# pred_bev_axes.legend(loc='best', shadow=True, fontsize=20)
# pred_2d_axes.legend(loc='best', shadow=True, fontsize=20)
# pred_3d_axes.legend(loc='best', shadow=True, fontsize=20)
else:
pred_fig, pred_3d_axes = \
vis_panoptic_utils.visualize_single_plot(
dataset.rgb_image_dir, img_idx, display=False)
draw_3d_predictions(filtered_gt_objs,
calib_p2,
num_of_predictions,
final_prediction_objs,
final_class_indices,
final_boxes_2d,
pred_3d_axes,
draw_prediction_score,
draw_prediction_iou,
gt_classes,
draw_orientations_on_pred,
distortion=distortion)
# Now add the legends
# pred_3d_axes.legend(loc='upper right', shadow=True, fontsize=20)
filename = pred_out_dir + '/' + sample_name + '.jpg'
plt.savefig(filename)
print('Draw predictions_separate: ', filename)
plt.close(pred_fig)
print('\nDone')
def main():
"""This demo shows RPN proposals and AVOD predictions in 3D
and 2D in image space. Given certain thresholds for proposals
and predictions, it selects and draws the bounding boxes on
the image sample. It goes through the entire proposal and
prediction samples for the given dataset split.
The proposals, overlaid, and prediction images can be toggled on or off
separately in the options section.
The prediction score and IoU with ground truth can be toggled on or off
as well, shown as (score, IoU) above the detection.
"""
dataset_config = DatasetBuilder.copy_config(DatasetBuilder.KITTI_VAL)
##############################
# Options
##############################
dataset_config = DatasetBuilder.merge_defaults(dataset_config)
dataset_config.data_split = 'val'
fig_size = (10, 6.1)
rpn_score_threshold = 0.1
avod_score_threshold = 0.1
# gt_classes = ['Car']
gt_classes = ['Pedestrian']
# gt_classes = ['Pedestrian', 'Cyclist']
# Overwrite this to select a specific checkpoint
global_step = 115000 # None
checkpoint_name = 'pplp_pedestrian_kitti'
# Drawing Toggles
draw_proposals_separate = False
draw_overlaid = True # To draw both proposal and predcition bounding boxes
draw_predictions_separate = False
# Show orientation for both GT and proposals/predictions
draw_orientations_on_prop = True
draw_orientations_on_pred = True
# Draw 2D bounding boxes
draw_projected_2d_boxes = True
# Draw pointclouds
draw_point_cloud = True
point_cloud_source = 'lidar'
slices_config = \
"""
slices {
height_lo: -1.0 # -0.2
height_hi: 2 # 2.3
num_slices: 1 # 5
}
"""
print('slices_config = ', slices_config)
text_format.Merge(slices_config,
dataset_config.kitti_utils_config.bev_generator)
# Save images for samples with no detections
save_empty_images = False
draw_score = True
draw_iou = True
##############################
# End of Options
##############################
# Get the dataset
dataset = DatasetBuilder.build_kitti_dataset(dataset_config,
use_defaults=False)
# Setup Paths
predictions_dir = pplp.root_dir() + \
'/data/outputs/' + checkpoint_name + '/predictions'
proposals_and_scores_dir = predictions_dir + \
'/proposals_and_scores/' + dataset.data_split
predictions_and_scores_dir = predictions_dir + \
'/final_predictions_and_scores/' + dataset.data_split
# Output images directories
output_dir_base = predictions_dir + '/images_2d'
# Get checkpoint step
steps = os.listdir(proposals_and_scores_dir)
steps.sort(key=int)
print('Available steps: {}'.format(steps))
# Use latest checkpoint if no index provided
if global_step is None:
global_step = steps[-1]
if draw_proposals_separate:
prop_out_dir = output_dir_base + '/proposals/{}/{}/{}'.format(
dataset.data_split, global_step, rpn_score_threshold)
if not os.path.exists(prop_out_dir):
os.makedirs(prop_out_dir)
print('Proposal images saved to:', prop_out_dir)
if draw_overlaid:
overlaid_out_dir = output_dir_base + '/overlaid/{}/{}/{}'.format(
dataset.data_split, global_step, avod_score_threshold)
if not os.path.exists(overlaid_out_dir):
os.makedirs(overlaid_out_dir)
print('Overlaid images saved to:', overlaid_out_dir)
if draw_predictions_separate:
pred_out_dir = output_dir_base + '/predictions/{}/{}/{}'.format(
dataset.data_split, global_step, avod_score_threshold)
if not os.path.exists(pred_out_dir):
os.makedirs(pred_out_dir)
print('Prediction images saved to:', pred_out_dir)
# Rolling average array of times for time estimation
avg_time_arr_length = 10
last_times = np.repeat(time.time(), avg_time_arr_length) + \
np.arange(avg_time_arr_length)
# for sample_idx in range(dataset.num_samples):
for sample_idx in [6]:
# Estimate time remaining with 5 slowest times
start_time = time.time()
last_times = np.roll(last_times, -1)
last_times[-1] = start_time
avg_time = np.mean(np.sort(np.diff(last_times))[-5:])
samples_remaining = dataset.num_samples - sample_idx
est_time_left = avg_time * samples_remaining
# Print progress and time remaining estimate
sys.stdout.write('\rSaving {} / {}, Avg Time: {:.3f}s, '
'Time Remaining: {:.2f}s'.format(
sample_idx + 1, dataset.num_samples, avg_time,
est_time_left))
sys.stdout.flush()
sample_name = dataset.sample_names[sample_idx]
img_idx = int(sample_name)
##############################
# Proposals
##############################
if draw_proposals_separate or draw_overlaid:
# Load proposals from files
proposals_file_path = proposals_and_scores_dir + \
"/{}/{}.txt".format(global_step, sample_name)
if not os.path.exists(proposals_file_path):
print('Sample {}: No proposals, skipping'.format(sample_name))
continue
print('Sample {}: Drawing proposals'.format(sample_name))
proposals_and_scores = np.loadtxt(proposals_file_path)
proposal_boxes_3d = proposals_and_scores[:, 0:7]
proposal_scores = proposals_and_scores[:, 7]
# Apply score mask to proposals
score_mask = proposal_scores > rpn_score_threshold
proposal_boxes_3d = proposal_boxes_3d[score_mask]
proposal_scores = proposal_scores[score_mask]
proposal_objs = \
[box_3d_encoder.box_3d_to_object_label(proposal,
obj_type='Proposal')
for proposal in proposal_boxes_3d]
##############################
# Predictions
##############################
if draw_predictions_separate or draw_overlaid:
predictions_file_path = predictions_and_scores_dir + \
"/{}/{}.txt".format(global_step,
sample_name)
if not os.path.exists(predictions_file_path):
continue
# Load predictions from files
predictions_and_scores = np.loadtxt(
predictions_and_scores_dir +
"/{}/{}.txt".format(global_step, sample_name))
prediction_boxes_3d = predictions_and_scores[:, 0:7]
prediction_scores = predictions_and_scores[:, 7]
prediction_class_indices = predictions_and_scores[:, 8]
# process predictions only if we have any predictions left after
# masking
if len(prediction_boxes_3d) > 0:
# Apply score mask
avod_score_mask = prediction_scores >= avod_score_threshold
prediction_boxes_3d = prediction_boxes_3d[avod_score_mask]
prediction_scores = prediction_scores[avod_score_mask]
prediction_class_indices = \
prediction_class_indices[avod_score_mask]
# # Swap l, w for predictions where w > l
# swapped_indices = \
# prediction_boxes_3d[:, 4] > prediction_boxes_3d[:, 3]
# prediction_boxes_3d = np.copy(prediction_boxes_3d)
# prediction_boxes_3d[swapped_indices, 3] = \
# prediction_boxes_3d[swapped_indices, 4]
# prediction_boxes_3d[swapped_indices, 4] = \
# prediction_boxes_3d[swapped_indices, 3]
##############################
# Ground Truth
##############################
# Get ground truth labels
if dataset.has_labels:
gt_objects = obj_utils.read_labels(dataset.label_dir, img_idx)
else:
gt_objects = []
# Filter objects to desired difficulty
filtered_gt_objs = dataset.kitti_utils.filter_labels(
gt_objects, classes=gt_classes)
boxes2d, _, _ = obj_utils.build_bbs_from_objects(
filtered_gt_objs, class_needed=gt_classes)
image_path = dataset.get_rgb_image_path(sample_name)
image = Image.open(image_path)
image_size = image.size
# Read the stereo calibration matrix for visualization
stereo_calib = calib_utils.read_calibration(dataset.calib_dir, img_idx)
calib_p2 = stereo_calib.p2
##############################
# Reformat and prepare to draw
##############################
if draw_proposals_separate or draw_overlaid:
proposals_as_anchors = box_3d_encoder.box_3d_to_anchor(
proposal_boxes_3d)
proposal_boxes, _ = anchor_projector.project_to_image_space(
proposals_as_anchors, calib_p2, image_size)
num_of_proposals = proposal_boxes_3d.shape[0]
prop_fig, prop_2d_axes, prop_3d_axes = \
vis_utils.visualization(dataset.rgb_image_dir,
img_idx,
display=False)
draw_proposals(filtered_gt_objs, calib_p2, num_of_proposals,
proposal_objs, proposal_boxes, prop_2d_axes,
prop_3d_axes, draw_orientations_on_prop)
if draw_point_cloud:
# Filter the useful pointclouds from all points
kitti_utils = dataset.kitti_utils
x, y, z, i = calib_utils.read_lidar(dataset.velo_dir, img_idx)
point_cloud = np.vstack((x, y, z))
# pts = calib_utils.lidar_to_cam_frame(pts, frame_calib)
# point_cloud = kitti_utils.get_point_cloud(
# point_cloud_source, img_idx, image_size)
point_cloud = kitti_utils.get_point_cloud(
point_cloud_source, img_idx, image_size)
print('point_cloud = ', point_cloud)
ground_plane = kitti_utils.get_ground_plane(sample_name)
all_points = np.transpose(point_cloud)
# print('dataset_config.kitti_utils_config.bev_generator.\
# slices.height_lo = ', dataset_config.kitti_utils_config.bev_generator.slices.height_lo)
height_lo = dataset_config.kitti_utils_config.bev_generator.slices.height_lo
height_hi = dataset_config.kitti_utils_config.bev_generator.slices.height_hi
# config = dataset.config.kitti_utils_config
# print('config = ', config)
area_extents = [[0., 70.], [-40, 40], [-1.1, -1]]
# ?,x,?
area_extents = np.reshape(area_extents, (3, 2))
print('area_extents = ', area_extents)
print('ground_plane = ', ground_plane)
slice_filter = get_point_filter(point_cloud,
area_extents,
ground_plane=None,
offset_dist=2.0)
# slice_filter = kitti_utils.create_slice_filter(
# point_cloud,
# area_extents,
# ground_plane,
# height_lo,
# height_hi)
# Apply slice filter
slice_points = all_points[slice_filter]
print('slice_points = ', slice_points)
# print('slice_points =', slice_points)
# Project the useful pointclouds on 2D image
point_2d = obj_utils.get_lidar_points_on_2D_image(
img_idx, dataset.calib_dir, dataset.velo_dir, image_size,
True, slice_points)
draw_points(prop_2d_axes, point_2d, 'red')
if draw_proposals_separate:
# Save just the proposals
filename = prop_out_dir + '/' + sample_name + '.png'
plt.savefig(filename)
if not draw_overlaid:
plt.close(prop_fig)
if draw_overlaid or draw_predictions_separate:
if len(prediction_boxes_3d) > 0:
# Project the 3D box predictions to image space
image_filter = []
final_boxes_2d = []
for i in range(len(prediction_boxes_3d)):
box_3d = prediction_boxes_3d[i, 0:7]
img_box = box_3d_projector.project_to_image_space(
box_3d,
calib_p2,
truncate=True,
image_size=image_size,
discard_before_truncation=False)
if img_box is not None:
image_filter.append(True)
final_boxes_2d.append(img_box)
else:
image_filter.append(False)
final_boxes_2d = np.asarray(final_boxes_2d)
final_prediction_boxes_3d = prediction_boxes_3d[image_filter]
final_scores = prediction_scores[image_filter]
final_class_indices = prediction_class_indices[image_filter]
num_of_predictions = final_boxes_2d.shape[0]
# Convert to objs
final_prediction_objs = \
[box_3d_encoder.box_3d_to_object_label(
prediction, obj_type='Prediction')
for prediction in final_prediction_boxes_3d]
for (obj, score) in zip(final_prediction_objs, final_scores):
obj.score = score
else:
if save_empty_images:
pred_fig, pred_2d_axes, pred_3d_axes = \
vis_utils.visualization(dataset.rgb_image_dir,
img_idx,
display=False,
fig_size=fig_size)
filename = pred_out_dir + '/' + sample_name + '.png'
plt.savefig(filename)
plt.close(pred_fig)
continue
if draw_overlaid:
# Overlay prediction boxes on image
draw_predictions(filtered_gt_objs, calib_p2,
num_of_predictions, final_prediction_objs,
final_class_indices, final_boxes_2d,
prop_2d_axes, prop_3d_axes, draw_score,
draw_iou, gt_classes,
draw_orientations_on_pred)
filename = overlaid_out_dir + '/' + sample_name + '.png'
plt.savefig(filename)
plt.close(prop_fig)
if draw_predictions_separate:
# Now only draw prediction boxes on images
# on a new figure handler
if draw_projected_2d_boxes:
pred_fig, pred_2d_axes, pred_3d_axes = \
vis_utils.visualization(dataset.rgb_image_dir,
img_idx,
display=False,
fig_size=fig_size)
draw_predictions(filtered_gt_objs, calib_p2,
num_of_predictions, final_prediction_objs,
final_class_indices, final_boxes_2d,
pred_2d_axes, pred_3d_axes, draw_score,
draw_iou, gt_classes,
draw_orientations_on_pred)
else:
pred_fig, pred_3d_axes = \
vis_utils.visualize_single_plot(
dataset.rgb_image_dir, img_idx, display=False)
draw_3d_predictions(filtered_gt_objs, calib_p2,
num_of_predictions,
final_prediction_objs,
final_class_indices, final_boxes_2d,
pred_3d_axes, draw_score, draw_iou,
gt_classes, draw_orientations_on_pred)
filename = pred_out_dir + '/' + sample_name + '.png'
plt.savefig(filename)
plt.close(pred_fig)
print('\nDone')
def get_configs_from_pipeline_file(pipeline_config_path, is_training):
"""Reads model configuration from a pipeline_pb2.NetworkPipelineConfig.
Args:
pipeline_config_path: A path directory to the network pipeline config
is_training: A boolean flag to indicate training stage, used for
creating the checkpoint directory which must be created at the
first training iteration.
Returns:
model_config: A model_pb2.ModelConfig
train_config: A train_pb2.TrainConfig
eval_config: A eval_pb2.EvalConfig
dataset_config: A kitti_dataset_pb2.KittiDatasetConfig
"""
pipeline_config = pipeline_pb2.NetworkPipelineConfig()
print('pipeline_config = ', pipeline_config)
with open(pipeline_config_path, 'r') as f:
text_format.Merge(f.read(), pipeline_config)
model_config = pipeline_config.model_config
# Make sure the checkpoint name matches the config filename
config_file_name = \
os.path.split(pipeline_config_path)[1].split('.')[0]
checkpoint_name = model_config.checkpoint_name
if config_file_name != checkpoint_name:
print('checkpoint_name =', checkpoint_name)
print('config_file_name =', config_file_name)
raise ValueError('Config and checkpoint names must match.')
output_root_dir = pplp.root_dir() + '/data/outputs/' + checkpoint_name
# Construct paths
paths_config = model_config.paths_config
if not paths_config.checkpoint_dir:
checkpoint_dir = output_root_dir + '/checkpoints'
if is_training:
if not os.path.exists(checkpoint_dir):
os.makedirs(checkpoint_dir)
paths_config.checkpoint_dir = checkpoint_dir
if not paths_config.logdir:
paths_config.logdir = output_root_dir + '/logs/'
if not paths_config.pred_dir:
paths_config.pred_dir = output_root_dir + '/predictions'
train_config = pipeline_config.train_config
eval_config = pipeline_config.eval_config
dataset_config = pipeline_config.dataset_config
if is_training:
# Copy the config to the experiments folder
experiment_config_path = output_root_dir + '/' +\
model_config.checkpoint_name
experiment_config_path += '.config'
# Copy this even if the config exists, in case some parameters
# were modified
shutil.copy(pipeline_config_path, experiment_config_path)
return model_config, train_config, eval_config, dataset_config
def save_predictions_in_panoptic_format(model,
checkpoint_name,
data_split,
score_threshold,
global_step):
""" Converts a set of network predictions into text files required for
PANOPTIC evaluation.
"""
dataset = model.dataset
# Round this because protobuf encodes default values as full decimal
score_threshold = round(score_threshold, 3)
# Get available prediction folders
predictions_root_dir = pplp.root_dir() + '/data/outputs/' + \
checkpoint_name + '/predictions'
final_predictions_root_dir = predictions_root_dir + \
'/final_predictions_and_scores/' + dataset.data_split
final_predictions_dir = final_predictions_root_dir + \
'/' + str(global_step)
# 3D prediction directories
panoptic_predictions_3d_dir = predictions_root_dir + \
'/panoptic_pplp_eval/' + \
str(score_threshold) + '/' + \
str(global_step) + '/data'
if not os.path.exists(panoptic_predictions_3d_dir):
os.makedirs(panoptic_predictions_3d_dir)
# Do conversion
num_samples = dataset.num_samples
num_valid_samples = 0
print('\nGlobal step:', global_step)
print('Converting detections from:', final_predictions_dir)
print('3D Detections being saved to:', panoptic_predictions_3d_dir)
for sample_idx in range(num_samples):
# Print progress
sys.stdout.write('\rConverting {} / {}'.format(
sample_idx + 1, num_samples))
sys.stdout.flush()
sample_name = dataset.sample_names[sample_idx]
prediction_file = sample_name + '.txt'
panoptic_predictions_3d_file_path = panoptic_predictions_3d_dir + \
'/' + prediction_file
predictions_file_path = final_predictions_dir + \
'/' + prediction_file
# If no predictions, skip to next file
if not os.path.exists(predictions_file_path):
np.savetxt(panoptic_predictions_3d_file_path, [])
continue
all_predictions = np.loadtxt(predictions_file_path)
# # Swap l, w for predictions where w > l
# swapped_indices = all_predictions[:, 4] > all_predictions[:, 3]
# fixed_predictions = np.copy(all_predictions)
# fixed_predictions[swapped_indices, 3] = all_predictions[
# swapped_indices, 4]
# fixed_predictions[swapped_indices, 4] = all_predictions[
# swapped_indices, 3]
all_predictions = np.array(all_predictions)
# change 1D array in to 2D array even if it has only one row.
if len(all_predictions.shape) == 1:
all_predictions.shape = (1, -1)
score_filter = all_predictions[:, 7] >= score_threshold
all_predictions = all_predictions[score_filter]
# If no predictions, skip to next file
if len(all_predictions) == 0:
np.savetxt(panoptic_predictions_3d_file_path, [])
continue
# Project to image space
sample_name = prediction_file.split('.')[0]
img_idx = int(sample_name)
# Load image for truncation
image = Image.open(dataset.get_rgb_image_path(sample_name))
stereo_calib_p2 = calib_panoptic_utils.read_calibration(dataset.calib_dir,
img_idx).HD_11
boxes = []
image_filter = []
for i in range(len(all_predictions)):
box_3d = all_predictions[i, 0:7]
img_box = box_3d_panoptic_projector.project_to_image_space(
box_3d, stereo_calib_p2,
truncate=True, image_size=image.size)
# Skip invalid boxes (outside image space)
if img_box is None:
image_filter.append(False)
print('**ERROR img_box = ', img_box)
continue
image_filter.append(True)
boxes.append(img_box)
boxes = np.asarray(boxes)
all_predictions = all_predictions[image_filter]
# If no predictions, skip to next file
if len(boxes) == 0:
np.savetxt(panoptic_predictions_3d_file_path, [])
continue
num_valid_samples += 1
# To keep each value in its appropriate position, an array of zeros
# (N, 16) is allocated but only values [4:16] are used
panoptic_predictions = np.zeros([len(boxes), 16])
# Get object types
all_pred_classes = all_predictions[:, 8].astype(np.int32)
obj_types = [dataset.classes[class_idx]
for class_idx in all_pred_classes]
# Truncation and Occlusion are always empty (see below)
# Alpha (Not computed)
panoptic_predictions[:, 3] = -10 * np.ones((len(panoptic_predictions)),
dtype=np.int32)
# 2D predictions
panoptic_predictions[:, 4:8] = boxes[:, 0:4]
# 3D predictions
# (l, w, h)
panoptic_predictions[:, 8] = all_predictions[:, 5]
panoptic_predictions[:, 9] = all_predictions[:, 4]
panoptic_predictions[:, 10] = all_predictions[:, 3]
# (x, y, z)
panoptic_predictions[:, 11:14] = all_predictions[:, 0:3]
# (ry, score)
panoptic_predictions[:, 14:16] = all_predictions[:, 6:8]
# Round detections to 3 decimal places
panoptic_predictions = np.round(panoptic_predictions, 3)
# Empty Truncation, Occlusion
panoptic_empty_1 = -1 * np.ones((len(panoptic_predictions), 2),
dtype=np.int32)
# Stack 3D predictions text
panoptic_text_3d = np.column_stack([obj_types,
panoptic_empty_1,
panoptic_predictions[:, 3:16]])
# Save to text files
np.savetxt(panoptic_predictions_3d_file_path, panoptic_text_3d,
newline='\r\n', fmt='%s')
print('\nNum valid:', num_valid_samples)
print('Num samples:', num_samples)
def main():
"""Generates anchors info which is used for mini batch sampling.
Processing on 'Cars' can be split into multiple processes, see the Options
section for configuration.
Args:
dataset: KittiDataset (optional)
If dataset is provided, only generate info for that dataset.
If no dataset provided, generates info for all 3 classes.
"""
kitti_dataset_config_path = pplp.root_dir() + \
'/configs/mb_preprocessing/rpn_pedestrians.config'
##############################
# Options
##############################
# Serial vs parallel processing
in_parallel = False
process_ped = True
# Number of child processes to fork, samples will
# be divided evenly amongst the processes (in_parallel must be True)
num_ped_children = 8
##############################
# Dataset setup
##############################
if process_ped:
ped_dataset = DatasetBuilder.load_dataset_from_config(
kitti_dataset_config_path)
##############################
# Serial Processing
##############################
if not in_parallel:
if process_ped:
do_preprocessing(ped_dataset, None)
print('All Done (Serial)')
##############################
# Parallel Processing
##############################
else:
# List of all child pids to wait on
all_child_pids = []
# Pedestrians
if process_ped:
ped_indices_split = split_indices(ped_dataset, num_ped_children)
split_work(all_child_pids, ped_dataset, ped_indices_split,
num_ped_children)
# Wait to child processes to finish
print('num children:', len(all_child_pids))
for i, child_pid in enumerate(all_child_pids):
os.waitpid(child_pid, 0)
print('All Done (Parallel)')
def __init__(self, dataset):
self._dataset = dataset
self._mini_batch_sampler = \
balanced_positive_negative_sampler.BalancedPositiveNegativeSampler()
##############################
# Parse KittiUtils config
##############################
self.kitti_utils_config = dataset.config.kitti_utils_config
self._area_extents = self.kitti_utils_config.area_extents
self._anchor_strides = np.reshape(
self.kitti_utils_config.anchor_strides, (-1, 2))
##############################
# Parse MiniBatchUtils config
##############################
self.config = self.kitti_utils_config.mini_batch_config
self._density_threshold = self.config.density_threshold
# RPN mini batches
rpn_config = self.config.rpn_config
rpn_iou_type = rpn_config.WhichOneof('iou_type')
if rpn_iou_type == 'iou_2d_thresholds':
self.rpn_iou_type = '2d'
self.rpn_iou_thresholds = rpn_config.iou_2d_thresholds
elif rpn_iou_type == 'iou_3d_thresholds':
self.rpn_iou_type = '3d'
self.rpn_iou_thresholds = rpn_config.iou_3d_thresholds
self.rpn_neg_iou_range = [
self.rpn_iou_thresholds.neg_iou_lo,
self.rpn_iou_thresholds.neg_iou_hi
]
self.rpn_pos_iou_range = [
self.rpn_iou_thresholds.pos_iou_lo,
self.rpn_iou_thresholds.pos_iou_hi
]
self.rpn_mini_batch_size = rpn_config.mini_batch_size
# AVOD mini batches
avod_config = self.config.avod_config
self.avod_iou_type = '2d'
self.avod_iou_thresholds = avod_config.iou_2d_thresholds
self.avod_neg_iou_range = [
self.avod_iou_thresholds.neg_iou_lo,
self.avod_iou_thresholds.neg_iou_hi
]
self.avod_pos_iou_range = [
self.avod_iou_thresholds.pos_iou_lo,
self.avod_iou_thresholds.pos_iou_hi
]
self.avod_mini_batch_size = avod_config.mini_batch_size
# Setup paths
self.mini_batch_dir = pplp.root_dir() + '/data/mini_batches/' + \
'iou_{}/'.format(self.rpn_iou_type) + \
dataset.name + '/' + dataset.cluster_split + '/' + \
dataset.bev_source
# Array column indices for saving to files
self.col_length = 9
self.col_anchor_indices = 0
self.col_ious = 1
self.col_offsets_lo = 2
self.col_offsets_hi = 8
self.col_class_idx = 8
class DatasetBuilder(object):
"""
Static class to return preconfigured dataset objects
"""
PANOPTIC_UNITTEST = PanopticDatasetConfig(
name="unittest-panoptic",
dataset_dir=pplp.root_dir() + "/tests/datasets/Panoptic/object",
data_split="train",
data_split_dir="training",
has_labels=True,
cluster_split="train",
classes=["Pedestrian"],
num_clusters=[1],
)
PANOPTIC_TRAIN = PanopticDatasetConfig(name="panoptic",
data_split="train",
data_split_dir="training",
has_labels=True,
cluster_split="train",
classes=["Pedestrian"],
num_clusters=[1])
PANOPTIC_VAL = PanopticDatasetConfig(
name="panoptic",
data_split="val",
data_split_dir="training",
has_labels=True,
cluster_split="train",
classes=["Pedestrian"],
num_clusters=[1],
)
PANOPTIC_TEST = PanopticDatasetConfig(
name="panoptic",
data_split="test",
data_split_dir="testing",
has_labels=False,
cluster_split="train",
classes=["Pedestrian"],
num_clusters=[1],
)
PANOPTIC_TRAINVAL = PanopticDatasetConfig(
name="panoptic",
data_split="trainval",
data_split_dir="training",
has_labels=True,
cluster_split="trainval",
classes=["Pedestrian"],
num_clusters=[1],
)
PANOPTIC_TRAIN_MINI = PanopticDatasetConfig(
name="panoptic",
data_split="train_mini",
data_split_dir="training",
has_labels=True,
cluster_split="train",
classes=["Pedestrian"],
num_clusters=[1],
)
PANOPTIC_VAL_MINI = PanopticDatasetConfig(
name="panoptic",
data_split="val_mini",
data_split_dir="training",
has_labels=True,
cluster_split="train",
classes=["Pedestrian"],
num_clusters=[1],
)
PANOPTIC_TEST_MINI = PanopticDatasetConfig(
name="panoptic",
data_split="test_mini",
data_split_dir="testing",
has_labels=False,
cluster_split="train",
classes=["Pedestrian"],
num_clusters=[1],
)
CONFIG_DEFAULTS_PROTO = \
"""
bev_source: 'lidar'
panoptic_utils_config {
area_extents: [-4, 4, -5, 3, 0, 7]
voxel_size: 0.01
anchor_strides: [0.5, 0.5]
bev_generator {
slices {
height_lo: -0.2
height_hi: 2.3
num_slices: 1
}
}
mini_batch_config {
density_threshold: 1
rpn_config {
iou_2d_thresholds {
neg_iou_lo: 0.0
neg_iou_hi: 0.3
pos_iou_lo: 0.5
pos_iou_hi: 1.0
}
# iou_3d_thresholds {
# neg_iou_lo: 0.0
# neg_iou_hi: 0.005
# pos_iou_lo: 0.1
# pos_iou_hi: 1.0
# }
mini_batch_size: 512
}
avod_config {
iou_2d_thresholds {
neg_iou_lo: 0.0
neg_iou_hi: 0.55
pos_iou_lo: 0.65
pos_iou_hi: 1.0
}
mini_batch_size: 1024
}
}
}
"""
@staticmethod
def load_dataset_from_config(dataset_config_path):
dataset_config = panoptic_dataset_pb2.PanopticDatasetConfig()
with open(dataset_config_path, 'r') as f:
text_format.Merge(f.read(), dataset_config)
return DatasetBuilder.build_panoptic_dataset(dataset_config,
use_defaults=False)
@staticmethod
def copy_config(cfg):
return deepcopy(cfg)
@staticmethod
def merge_defaults(cfg):
cfg_copy = DatasetBuilder.copy_config(cfg)
text_format.Merge(DatasetBuilder.CONFIG_DEFAULTS_PROTO, cfg_copy)
return cfg_copy
@staticmethod
def build_panoptic_dataset(base_cfg,
use_defaults=True,
new_cfg=None) -> PanopticDataset:
"""Builds a PanopticDataset object using the provided configurations
Args:
base_cfg: a base dataset configuration
use_defaults: whether to use the default config values
new_cfg: (optional) a custom dataset configuration, no default
values will be used, all config values must be provided
Returns:
PanopticDataset object
"""
cfg_copy = DatasetBuilder.copy_config(base_cfg)
if use_defaults:
# Use default values
text_format.Merge(DatasetBuilder.CONFIG_DEFAULTS_PROTO, cfg_copy)
if new_cfg:
# Use new config values if provided
cfg_copy.MergeFrom(new_cfg)
return PanopticDataset(cfg_copy)
