def generate_rpn_training_labels(pts_rect, gt_boxes3d):
cls_label = np.zeros((pts_rect.shape[0]), dtype=np.int32)
reg_label = np.zeros((pts_rect.shape[0], 7), dtype=np.float32) # dx, dy, dz, ry, h, w, l
gt_corners = kitti_utils.boxes3d_to_corners3d(gt_boxes3d, rotate=True)
extend_gt_boxes3d = kitti_utils.enlarge_box3d(gt_boxes3d, extra_width=0.2)
extend_gt_corners = kitti_utils.boxes3d_to_corners3d(extend_gt_boxes3d, rotate=True)
for k in range(gt_boxes3d.shape[0]):
box_corners = gt_corners[k]
fg_pt_flag = kitti_utils.in_hull(pts_rect, box_corners)
fg_pts_rect = pts_rect[fg_pt_flag]
cls_label[fg_pt_flag] = 1
# enlarge the bbox3d, ignore nearby points
extend_box_corners = extend_gt_corners[k]
fg_enlarge_flag = kitti_utils.in_hull(pts_rect, extend_box_corners)
ignore_flag = np.logical_xor(fg_pt_flag, fg_enlarge_flag)
cls_label[ignore_flag] = -1
# pixel offset of object center
center3d = gt_boxes3d[k][0:3].copy() # (x, y, z)
center3d[1] -= gt_boxes3d[k][3] / 2
reg_label[fg_pt_flag, 0:3] = center3d - fg_pts_rect # Now y is the true center of 3d box 20180928
# size and angle encoding
reg_label[fg_pt_flag, 3] = gt_boxes3d[k][3] # h
reg_label[fg_pt_flag, 4] = gt_boxes3d[k][4] # w
reg_label[fg_pt_flag, 5] = gt_boxes3d[k][5] # l
reg_label[fg_pt_flag, 6] = gt_boxes3d[k][6] # ry
return cls_label, reg_label
def generate_rpn_training_labels(pts_rect, gt_boxes3d, gt_corners):
'''
Inputs:
pts_rect : points in the scene
gt_boxes3d: the boxes in the form of x,y,z, w,h,l , rx,ry,rz, class_num
gt_bbox_list_corners: 8 box corners corresponding to the aug_gt_boxes3d list
but in a dictionary with keys class numbers (string)
Returns:
cls_label: sets the class of each point inside the original bboxes to 1 other points 0.
reg_label: for regression target(reg_label) we use the same w,h,l , rx,ry,rz as the bbox for each point belonging to that bbox.
but the x,y,z of the center of the box are transformed into dx, dy, dz (box center subtracted from point's coordinates)
order of each row : dx, dy, dz, w,h,l , rx,ry,rz
'''
cls_label = np.zeros((pts_rect.shape[0]), dtype=np.int32)
reg_label = np.zeros((pts_rect.shape[0], 9),
dtype=np.float32) # dx, dy, dz, ry, h, w, l
# turn gt_corners into a simple 2D np array
bbox_corners = []
for _, value in gt_corners.items():
for corners in value:
bbox_corners.append(corners)
gt_corners = np.asarray(bbox_corners)
for k in range(gt_boxes3d.shape[0]):
box_corners = gt_corners[k]
# determin which points inside the box (it's a mask) (Trues are inside)
fg_pt_flag = kitti_utils.in_hull(pts_rect, box_corners)
fg_pts_rect = pts_rect[fg_pt_flag]
cls_label[fg_pt_flag] = 1
# pixel offset of object center
center3d = gt_boxes3d[k][0:3].copy() # (x, y, z)
# center all points inside box around the box center
# I have no idea why this is written as center-points instead of points-center which would be more natural
reg_label[fg_pt_flag, 0:3] = center3d - fg_pts_rect
# size and angle encoding
reg_label[fg_pt_flag, 3] = gt_boxes3d[k][3] # w
reg_label[fg_pt_flag, 4] = gt_boxes3d[k][4] # h
reg_label[fg_pt_flag, 5] = gt_boxes3d[k][5] # l
reg_label[fg_pt_flag, 6] = gt_boxes3d[k][6] # rx
reg_label[fg_pt_flag, 7] = gt_boxes3d[k][7] # ry
reg_label[fg_pt_flag, 8] = gt_boxes3d[k][8] # rz
# check all the returns are non zero (at-least 1 nonzero element)
#assert cls_label.any(), 'cls_label is all 0s !'
#assert reg_label.any(), 'reg_label is all 0s !'
return cls_label, reg_label
h_list.append(label.h)
ry_list.append(label.ry)
points = align_img_and_pc(img_dir, pc_dir, calib_dir)
# print("numpoints: ", len(points))
num_pts_per_scene.append(len(points))
# Get the foreground and background label
bboxes3d = kitti_utils.objs_to_boxes3d(labels)
# print("Number of bboxes: ",len(bboxes3d))
bboxes3d_rotated_corners = kitti_utils.boxes3d_to_corners3d(bboxes3d)
box3d_roi_inds_overall = None
sub_box3d_roi_inds_overall = None
valid_labels = []
for i, bbox3d_corners in enumerate(bboxes3d_rotated_corners):
# print("bboxes3d_rotated_corners: ", bboxes3d_rotated_corners[i])
box3d_roi_inds = kitti_utils.in_hull(points[:, :3], bbox3d_corners)
# box3d_roi_inds = kitti_utils.in_hull(bbox3d_corners[:,:3], bbox3d_corners)
# print("xmin: ", np.min(points[:,0]), " xmax: ", np.max(points[:,0]))
# print("ymin: ", np.min(points[:,1]), " ymax: ", np.max(points[:,1]))
# print("zmin: ", np.min(points[:,2]), " zmax: ", np.max(points[:,2]))
# pc_filter = kitti_utils.extract_pc_in_box3d(points[:,:3], bbox3d_corners)
# sub_pc_filter = kitti_utils.extract_pc_in_box3d(points[:,:3], bbox3d_corners)
# print("pc_filter.shape: ", pc_filter[0].shape)
# print("interested indices shape: ", box3d_roi_inds.shape)
# print("interested indices: ", box3d_roi_inds)
# print("number of obj points: ", np.sum(box3d_roi_inds))
if np.sum(box3d_roi_inds) < 10:
continue
valid_labels.append(labels[i])
# print(type(box3d_roi_inds))
if box3d_roi_inds_overall is None:
gt_mask = np.zeros((cur_prob_mask.shape))
if foreground_flag[i] == True:
fg_flag = True
if foreground_flag_G[i] == True:
box_id = proposal_gt_index[i].detach().cpu().numpy()
gt_box = gt_boxes3d_cam[box_id].detach().cpu().numpy().reshape(7)
gt_box[0] = gt_box[0] - cur_pts_center[0]
gt_box[2] = gt_box[2] - cur_pts_center[2]
gt_box[3] = gt_box[3] * 1.2
gt_box[4] = gt_box[4] * 1.2
gt_box[5] = gt_box[5] * 1.2
gt_corners = kitti_utils.boxes3d_to_corners3d(gt_box.reshape(
-1, 7),
rotate=True)
gt_mask = kitti_utils.in_hull(cur_box_point,
gt_corners.reshape(-1, 3)).reshape(
-1, 1)
gt_box = gt_boxes3d_cam[box_id].detach().cpu().numpy().reshape(7)
gt_box[0] = gt_box[0] - cur_pts_center[0]
gt_box[2] = gt_box[2] - cur_pts_center[2]
# fig, ax = plt.subplots(figsize=(5, 5))
# plt.title('%d / %d'%(box_id, gt_boxes3d_cam.shape[0]))
# ax.axis([-4, 4, -4, 4])
# plt.scatter(cur_box_point[:, 0], cur_box_point[:, 2], s=15, c=cur_prob_mask[:,0], edgecolor='none',
# cmap=plt.get_cmap('rainbow'), alpha=1, marker='.', vmin=0, vmax=1)
# plt.scatter(np.zeros(1), np.zeros(1), s=200, c='black',
# alpha=0.5, marker='x', vmin=-1, vmax=1)
# if foreground_flag[i] == True:
# plt.scatter(gt_box[0], gt_box[2], s=200, c='blue',
