def generate_prediction_dict(input_dict, index, record_dict):
# finally generate predictions.
sample_idx = input_dict['sample_idx'][
index] if 'sample_idx' in input_dict else -1
boxes3d_lidar_preds = record_dict['boxes'].cpu().numpy()
if boxes3d_lidar_preds.shape[0] == 0:
return {'sample_idx': sample_idx}
calib = input_dict['calib'][index]
image_shape = input_dict['image_shape'][index]
boxes3d_camera_preds = box_utils.boxes3d_lidar_to_camera(
boxes3d_lidar_preds, calib)
boxes2d_image_preds = box_utils.boxes3d_camera_to_imageboxes(
boxes3d_camera_preds, calib, image_shape=image_shape)
# predictions
predictions_dict = {
'bbox': boxes2d_image_preds,
'box3d_camera': boxes3d_camera_preds,
'box3d_lidar': boxes3d_lidar_preds,
'scores': record_dict['scores'].cpu().numpy(),
'label_preds': record_dict['labels'].cpu().numpy(),
'sample_idx': sample_idx,
}
return predictions_dict
def get_annotation_from_label(self, calib, sample_idx):
date, set_num, idx = sample_idx
obj_list = self.get_label(sample_idx)[int(idx)]['cuboids']
annotations = {}
annotations['name'] = np.array([obj['label'] for obj in obj_list])
annotations['num_points_in_gt'] = [[
obj['points_count'] for obj in obj_list
]]
loc_lidar = np.array([[
obj['position']['x'], obj['position']['y'], obj['position']['z']
] for obj in obj_list])
dims = np.array([[
obj['dimensions']['x'], obj['dimensions']['y'],
obj['dimensions']['z']
] for obj in obj_list])
rots = np.array([obj['yaw'] for obj in obj_list])
gt_boxes_lidar = np.concatenate(
[loc_lidar, dims, rots[..., np.newaxis]], axis=1)
annotations['gt_boxes_lidar'] = gt_boxes_lidar
# in camera 0 frame. Probably meaningless as most objects aren't in frame.
annotations['location'] = calib.lidar_to_rect(loc_lidar)
annotations['rotation_y'] = rots
annotations['dimensions'] = np.array([[
obj['dimensions']['y'], obj['dimensions']['z'],
obj['dimensions']['x']
] for obj in obj_list]) # lhw format
gt_boxes_camera = box_utils.boxes3d_lidar_to_camera(
gt_boxes_lidar, calib)
# Currently unused for CADC, and don't make too much since as we primarily use 360 degree 3d LIDAR boxes.
annotations['score'] = np.array([1 for _ in obj_list])
annotations['difficulty'] = np.array([0 for obj in obj_list], np.int32)
annotations['truncated'] = np.array([0 for _ in obj_list])
annotations['occluded'] = np.array([0 for _ in obj_list])
annotations['alpha'] = np.array([
-np.arctan2(-gt_boxes_lidar[i][1], gt_boxes_lidar[i][0]) +
gt_boxes_camera[i][6] for i in range(len(obj_list))
])
annotations['bbox'] = gt_boxes_camera
return annotations
def generate_prediction_dict(input_dict, index, record_dict):
"""
Generate the prediction dict for EACH sample, called by the post processing. All this fn
does really is mapping prediciton boxes to camera coordinates putting things together in
a predictions_dict.
Args:
input_dict: provided by the dataset to provide dataset-specific information
index: batch index of current sample
record_dict: the predicted results of current sample from the detector,
which currently includes these keys: {
'boxes': (N, 7 + C) [x, y, z, w, l, h, heading_in_kitti] in LiDAR coords
'scores': (N)
'labels': (N）
}
Returns:
predictions_dict: the required prediction dict of current scene for specific dataset
"""
# finally generate predictions.
sample_idx = input_dict['sample_idx'][
index] if 'sample_idx' in input_dict else -1
boxes3d_lidar_preds = record_dict['boxes'].cpu().numpy()
if boxes3d_lidar_preds.shape[0] == 0:
return {'sample_idx': sample_idx}
calib = input_dict['calib'][index]
image_shape = input_dict['image_shape'][index]
boxes3d_camera_preds = box_utils.boxes3d_lidar_to_camera(
boxes3d_lidar_preds, calib)
boxes2d_image_preds = box_utils.boxes3d_camera_to_imageboxes(
boxes3d_camera_preds, calib, image_shape=image_shape)
# predictions
predictions_dict = {
'bbox': boxes2d_image_preds,
'box3d_camera': boxes3d_camera_preds,
'box3d_lidar': boxes3d_lidar_preds,
'scores': record_dict['scores'].cpu().numpy(),
'label_preds': record_dict['labels'].cpu().numpy(),
'sample_idx': sample_idx,
}
return predictions_dict
def generate_prediction_dict(input_dict, index, record_dict):
# finally generate predictions.
sample_idx = input_dict['sample_idx'][
index] if 'sample_idx' in input_dict else -1
try:
boxes3d_lidar_preds = record_dict['boxes'].cpu().numpy()
except:
boxes3d_lidar_preds = record_dict['boxes'].detach().cpu().numpy()
if boxes3d_lidar_preds.shape[0] == 0:
return {'sample_idx': sample_idx}
if not cfg.DATA_CONFIG.TS_DATA:
calib = input_dict['calib'][index]
image_shape = input_dict['image_shape'][index]
boxes3d_camera_preds = box_utils.boxes3d_lidar_to_camera(
boxes3d_lidar_preds, calib)
boxes2d_image_preds = box_utils.boxes3d_camera_to_imageboxes(
boxes3d_camera_preds, calib, image_shape=image_shape)
# predictions
predictions_dict = {
'bbox': boxes2d_image_preds,
'box3d_camera': boxes3d_camera_preds,
'box3d_lidar': boxes3d_lidar_preds,
'scores': record_dict['scores'].cpu().numpy(),
'label_preds': record_dict['labels'].cpu().numpy(),
'sample_idx': sample_idx,
}
else:
boxes3d_camera_preds = box_utils.ts_boxes3d_lidar_to_camera(
boxes3d_lidar_preds)
predictions_dict = {
'bbox': np.zeros((boxes3d_lidar_preds.shape[0], 4)),
'box3d_camera': boxes3d_camera_preds,
'box3d_lidar': boxes3d_lidar_preds,
'scores': record_dict['scores'].detach().cpu().numpy(),
'label_preds': record_dict['labels'].detach().cpu().numpy(),
'sample_idx': sample_idx,
}
return predictions_dict
def get_annotation_from_label(self, calib, sample_token):
box_list = self.get_label(sample_token, sensor='LIDAR_TOP')
if (len(box_list) == 0):
annotations = {}
annotations['name'] = annotations['num_points_in_gt'] = annotations['gt_boxes_lidar'] = \
annotations['token'] = annotations['location'] = annotations['rotation_y'] = \
annotations['dimensions'] = annotations['score'] = annotations['difficulty'] = \
annotations['truncated'] = annotations['occluded'] = annotations['alpha'] = annotations['bbox'] = np.array([])
return None
annotations = {}
gt_names = np.array([
self.NameMapping[box.name]
if box.name in self.NameMapping else 'DontCare' for box in box_list
])
num_points_in_gt = np.array([
self.nusc.get('sample_annotation', box.token)['num_lidar_pts']
for box in box_list
])
loc_lidar = np.array([box.center for box in box_list])
dims = np.array([box.wlh for box in box_list])
#loc_lidar[:,2] -= dims[:,2] / 2 # Translate true center to bottom middle coordinate
rots = np.array(
[box.orientation.yaw_pitch_roll[0] for box in box_list])
gt_boxes_lidar = np.concatenate(
[loc_lidar, dims, rots[..., np.newaxis]], axis=1)
annotations['name'] = gt_names
annotations['num_points_in_gt'] = num_points_in_gt
annotations['gt_boxes_lidar'] = gt_boxes_lidar
annotations['token'] = np.array([box.token for box in box_list])
# in CAM_FRONT frame. Probably meaningless as most objects aren't in frame.
annotations['location'] = calib.lidar_to_rect(loc_lidar)
annotations['rotation_y'] = rots
annotations['dimensions'] = np.array(
[[box.wlh[1], box.wlh[2], box.wlh[0]]
for box in box_list]) # lhw format
occluded = np.zeros([num_points_in_gt.shape[0]])
easy_mask = num_points_in_gt > 15
moderate_mask = num_points_in_gt > 7
occluded = np.zeros([num_points_in_gt.shape[0]])
occluded[:] = 2
occluded[moderate_mask] = 1
occluded[easy_mask] = 0
gt_boxes_camera = box_utils.boxes3d_lidar_to_camera(
gt_boxes_lidar, calib)
assert len(gt_boxes_camera) == len(gt_boxes_lidar) == len(box_list)
# Currently unused for NuScenes, and don't make too much since as we primarily use 360 degree 3d LIDAR boxes.
annotations['score'] = np.array([1 for _ in box_list])
annotations['difficulty'] = np.array([0 for _ in box_list], np.int32)
annotations['truncated'] = np.array([0 for _ in box_list])
annotations['occluded'] = occluded
annotations['alpha'] = np.array([
-np.arctan2(-gt_boxes_lidar[i][1], gt_boxes_lidar[i][0]) +
gt_boxes_camera[i][6] for i in range(len(gt_boxes_camera))
])
annotations['bbox'] = gt_boxes_camera
return annotations