def augment_bv(blobs, scale=0.5): #just do translation to bv_image, scale is in meters sx, sy = np.random.uniform(-scale, scale, 2) #shift gt_boxes_3D, gt_boxes_corner, gt_boxes_bv blobs['gt_boxes_3d'][:, 0] += sx blobs['gt_boxes_3d'][:, 1] += sy #WZN: disable corners blobs['gt_boxes_corners'][:, 0:8] += sx blobs['gt_boxes_corners'][:, 8:16] += sy blobs['gt_boxes_bv_corners'][:, 0:8] = lidar_cnr_to_bv_cnr( blobs['gt_boxes_corners'][:, 0:24]) blobs['gt_boxes_bv'][:, 0:4] = lidar_3d_to_bv(blobs['gt_boxes_3d']) #shift lidar_bv_data sx_bv, sy_bv = _lidar_shift_to_bv_shift(sx, sy) sx_bv = np.round(sx_bv).astype(int) sy_bv = np.round(sy_bv).astype(int) blobs['lidar_bv_data'][0, :, :, :] = np.roll( blobs['lidar_bv_data'][0, :, :, :], [sy_bv, sx_bv], axis=[0, 1]) if sy_bv >= 0: blobs['lidar_bv_data'][0, 0:sy_bv:, :, :] = 0 else: blobs['lidar_bv_data'][0, sy_bv:, :, :] = 0 if sx_bv >= 0: blobs['lidar_bv_data'][0, :, 0:sx_bv:, :] = 0 else: blobs['lidar_bv_data'][0, :, sx_bv:, :] = 0 #shift bv_index, clip bv_index,img_index blobs['bv_index'][:, 0] += sx_bv blobs['bv_index'][:, 1] += sy_bv clip_indx = np.logical_and( blobs['bv_index'][:, 0] >= 0, blobs['bv_index'][:, 0] < blobs['lidar_bv_data'].shape[1]) clip_indy = np.logical_and( blobs['bv_index'][:, 1] >= 0, blobs['bv_index'][:, 1] < blobs['lidar_bv_data'].shape[2]) clip_indx = np.logical_and(clip_indx, clip_indy) blobs['bv_index'] = blobs['bv_index'][clip_indx, :] blobs['img_index'] = blobs['img_index'][:, clip_indx] #shift calib Tr = np.reshape(blobs['calib'][3, :], (3, 4)) Tr[:, 3] += np.dot(Tr[:, 0:3], -np.array([sx, sy, 0])) blobs['calib'][3, :] = np.reshape(Tr, (-1)) return blobs
def proposal_layer_3d(rpn_cls_prob_reshape, rpn_bbox_pred, im_info, calib, cfg_key, _feat_stride=[ 8, ], anchor_scales=[1.0, 1.0]): # Algorithm: # # for each (H, W) location i # generate A anchor boxes centered on cell i # apply predicted bbox deltas at cell i to each of the A anchors # clip predicted boxes to image # remove predicted boxes with either height or width < threshold # sort all (proposal, score) pairs by score from highest to lowest # take top pre_nms_topN proposals before NMS # apply NMS with threshold 0.7 to remaining proposals # take after_nms_topN proposals after NMS # return the top proposals (-> RoIs top, scores top) #layer_params = yaml.load(self.param_str_) _anchors = generate_anchors_bv() # _anchors = generate_anchors(scales=np.array(anchor_scales)) _num_anchors = _anchors.shape[0] #print "aaaaaaa",_anchors.shape (4,4) #print "bbbbbbb",im_info (601,601,1) #print "ccccccc", calib.shape (4,12) im_info = im_info[0] assert rpn_cls_prob_reshape.shape[0] == 1, \ 'Only single item batches are supported' # cfg_key = str(self.phase) # either 'TRAIN' or 'TEST' pre_nms_topN = cfg[cfg_key].RPN_PRE_NMS_TOP_N post_nms_topN = cfg[cfg_key].RPN_POST_NMS_TOP_N nms_thresh = cfg[cfg_key].RPN_NMS_THRESH min_size = cfg[cfg_key].RPN_MIN_SIZE # the first set of _num_anchors channels are bg probs # the second set are the fg probs, which we want # print rpn_cls_prob_reshape.shape height, width = rpn_cls_prob_reshape.shape[1:3] # scores = rpn_cls_prob_reshape[:, _num_anchors:, :, :] scores = np.reshape( np.reshape(rpn_cls_prob_reshape, [1, height, width, _num_anchors, 2])[:, :, :, :, 1], [1, height, width, _num_anchors]) bbox_deltas = rpn_bbox_pred if DEBUG: print 'im_size: ({}, {})'.format(im_info[0], im_info[1]) print 'scale: {}'.format(im_info[2]) # 1. Generate proposals from bbox deltas and shifted anchors if DEBUG: print 'score map size: {}'.format(scores.shape) # Enumerate all shifts shift_x = np.arange(0, width) * _feat_stride shift_y = np.arange(0, height) * _feat_stride shift_x, shift_y = np.meshgrid(shift_x, shift_y) shifts = np.vstack((shift_x.ravel(), shift_y.ravel(), shift_x.ravel(), shift_y.ravel())).transpose() # Enumerate all shifted anchors: # # add A anchors (1, A, 4) to # cell K shifts (K, 1, 4) to get # shift anchors (K, A, 4) # reshape to (K*A, 4) shifted anchors A = _num_anchors K = shifts.shape[0] anchors = _anchors.reshape((1, A, 4)) + \ shifts.reshape((1, K, 4)).transpose((1, 0, 2)) anchors = anchors.reshape((K * A, 4)) # Transpose and reshape predicted bbox transformations to get them # into the same order as the anchors: # # bbox deltas will be (1, 4 * A, H, W) format # transpose to (1, H, W, 4 * A) # reshape to (1 * H * W * A, 4) where rows are ordered by (h, w, a) # in slowest to fastest order # bbox_deltas = bbox_deltas.transpose((0, 2, 3, 1)).reshape((-1, 6)) bbox_deltas = bbox_deltas.reshape((-1, 6)) # print "bbox_deltas",bbox_deltas.shape # print anchors.shape # Same story for the scores: # # scores are (1, A, H, W) format # transpose to (1, H, W, A) # reshape to (1 * H * W * A, 1) where rows are ordered by (h, w, a) # scores = scores.transpose((0, 2, 3, 1)).reshape((-1, 1)) scores = scores.reshape((-1, 1)) # print np.sort(scores.ravel())[-30:] # convert anchors bv to anchors_3d anchors_3d = bv_anchor_to_lidar(anchors) # Convert anchors into proposals via bbox transformations proposals_3d = bbox_transform_inv_3d(anchors_3d, bbox_deltas) # convert back to lidar_bv proposals_bv = lidar_3d_to_bv(proposals_3d) lidar_corners = lidar_3d_to_corners(proposals_3d) proposals_img = lidar_cnr_to_img(lidar_corners, calib[3], calib[2], calib[0]) if DEBUG: # print "bbox_deltas: ", bbox_deltas[:10] # print "proposals number: ", proposals_3d[:10] print "proposals_bv shape: ", proposals_bv.shape print "proposals_3d shape: ", proposals_3d.shape print "proposals_img shape:", proposals_img.shape # 2. clip predicted boxes to image proposals_bv = clip_boxes(proposals_bv, im_info[:2]) # 3. remove predicted boxes with either height or width < threshold # (NOTE: convert min_size to input image scale stored in im_info[2]) keep = _filter_boxes(proposals_bv, min_size * im_info[2]) proposals_bv = proposals_bv[keep, :] proposals_3d = proposals_3d[keep, :] proposals_img = proposals_img[keep, :] scores = scores[keep] # TODO: pass real image_info keep = _filter_img_boxes(proposals_img, [375, 1242]) proposals_bv = proposals_bv[keep, :] proposals_3d = proposals_3d[keep, :] proposals_img = proposals_img[keep, :] scores = scores[keep] if DEBUG: print "proposals after clip" print "proposals_bv shape: ", proposals_bv.shape print "proposals_3d shape: ", proposals_3d.shape print "proposals_img shape: ", proposals_img.shape # 4. sort all (proposal, score) pairs by score from highest to lowest # 5. take top pre_nms_topN (e.g. 6000) order = scores.ravel().argsort()[::-1] if pre_nms_topN > 0: order = order[:pre_nms_topN] proposals_bv = proposals_bv[order, :] proposals_3d = proposals_3d[order, :] proposals_img = proposals_img[order, :] scores = scores[order] # 6. apply nms (e.g. threshold = 0.7) # 7. take after_nms_topN (e.g. 300) # 8. return the top proposals (-> RoIs top) keep = nms(np.hstack((proposals_bv, scores)), nms_thresh) if post_nms_topN > 0: keep = keep[:post_nms_topN] proposals_bv = proposals_bv[keep, :] proposals_3d = proposals_3d[keep, :] proposals_img = proposals_img[keep, :] scores = scores[keep] if DEBUG: print "proposals after nms" print "proposals_bv shape: ", proposals_bv.shape print "proposals_3d shape: ", proposals_3d.shape # Output rois blob # Our RPN implementation only supports a single input image, so all # batch inds are 0 batch_inds = np.zeros((proposals_bv.shape[0], 1), dtype=np.float32) blob_bv = np.hstack((batch_inds, proposals_bv.astype(np.float32, copy=False))) blob_img = np.hstack( (batch_inds, proposals_img.astype(np.float32, copy=False))) blob_3d = np.hstack((batch_inds, proposals_3d.astype(np.float32, copy=False))) if DEBUG: print "blob shape ====================:" print blob_bv.shape print blob_img.shape # print '3d', blob_3d[:10] # print lidar_corners[:10] # print 'bv', blob_bv[:10] # print 'img', blob_img[:10] return blob_bv, blob_img, blob_3d
def proposal_layer_3d_debug(rpn_cls_prob_reshape,rpn_bbox_pred,im_info,calib,cfg_in, _feat_stride = [8,], anchor_scales=[1.0, 1.0],debug_state=True): #copy part of the code from proposal_layer_3d for debug _anchors = generate_anchors_bv() # _anchors = generate_anchors(scales=np.array(anchor_scales)) _num_anchors = _anchors.shape[0] im_info = im_info[0] assert rpn_cls_prob_reshape.shape[0] == 1, \ 'Only single item batches are supported' # cfg_key = str(self.phase) # either 'TRAIN' or 'TEST' # the first set of _num_anchors channels are bg probs # the second set are the fg probs, which we want # print rpn_cls_prob_reshape.shape height, width = rpn_cls_prob_reshape.shape[1:3] # scores = rpn_cls_prob_reshape[:, _num_anchors:, :, :] scores = np.reshape(np.reshape(rpn_cls_prob_reshape, [1, height, width, _num_anchors, 2])[:,:,:,:,1],[1, height, width, _num_anchors]) bbox_deltas = rpn_bbox_pred if debug_state: print ('im_size: ({}, {})'.format(im_info[0], im_info[1])) print ('scale: {}'.format(im_info[2])) if debug_state: print ('score map size: {}'.format(scores.shape)) # Enumerate all shifts shift_x = np.arange(0, width) * _feat_stride shift_y = np.arange(0, height) * _feat_stride shift_x, shift_y = np.meshgrid(shift_x, shift_y) shifts = np.vstack((shift_x.ravel(), shift_y.ravel(), shift_x.ravel(), shift_y.ravel())).transpose() # Enumerate all shifted anchors: # # add A anchors (1, A, 4) to # cell K shifts (K, 1, 4) to get # shift anchors (K, A, 4) # reshape to (K*A, 4) shifted anchors A = _num_anchors K = shifts.shape[0] anchors = _anchors.reshape((1, A, 4)) + \ shifts.reshape((1, K, 4)).transpose((1, 0, 2)) anchors = anchors.reshape((K * A, 4)) bbox_deltas = bbox_deltas.reshape((-1, 6)) scores = scores.reshape((-1, 1)) # convert anchors bv to anchors_3d anchors_3d = bv_anchor_to_lidar(anchors) # Convert anchors into proposals via bbox transformations proposals_3d = bbox_transform_inv_3d(anchors_3d, bbox_deltas) # convert back to lidar_bv proposals_bv = lidar_3d_to_bv(proposals_3d) #[x1,y1,x2,y2] lidar_corners = lidar_3d_to_corners(proposals_3d) proposals_img = lidar_cnr_to_img(lidar_corners, calib[3], calib[2], calib[0]) if debug_state: # print "bbox_deltas: ", bbox_deltas[:10] # print "proposals number: ", proposals_3d[:10] print ("proposals_bv shape: ", proposals_bv.shape) print ("proposals_3d shape: ", proposals_3d.shape) print ("scores shape:", scores.shape) # 2. clip predicted boxes to image #WZN: delete those not in image ind_inside = clip_anchors(anchors, im_info[:2]) #ind_inside = np.logical_and(ind_inside,clip_anchors(proposals_bv, im_info[:2])) proposals_bv = proposals_bv[ind_inside,:] proposals_3d = proposals_3d[ind_inside,:] proposals_img = proposals_img[ind_inside,:] scores = scores[ind_inside,:] proposals_bv = clip_boxes(proposals_bv, im_info[:2]) # TODO: pass real image_info #keep = _filter_img_boxes(proposals_img, [375, 1242]) #proposals_bv = proposals_bv[keep, :] #proposals_3d = proposals_3d[keep, :] #proposals_img = proposals_img[keep, :] #scores = scores[keep] if debug_state: print ("proposals after clip") print ("proposals_bv shape: ", proposals_bv.shape) print ("proposals_3d shape: ", proposals_3d.shape) print ("proposals_img shape: ", proposals_img.shape) # 4. sort all (proposal, score) pairs by score from highest to lowest # 5. take top pre_nms_topN (e.g. 6000) order = scores.ravel().argsort()[::-1] if cfg_in['pre_keep_topN'] > 0: order = order[:cfg_in['pre_keep_topN']] #keep = keep[order] proposals_bv = proposals_bv[order, :] proposals_3d = proposals_3d[order, :] proposals_img = proposals_img[order, :] scores = scores[order] # 6. apply nms (e.g. threshold = 0.7) # 7. take after_nms_topN (e.g. 300) # 8. return the top proposals (-> RoIs top) if cfg_in['use_nms']: keep = nms(np.hstack((proposals_bv, scores)), cfg_in['nms_thresh']) if cfg_in['nms_topN'] > 0: keep = keep[:cfg_in['nms_topN']] proposals_bv = proposals_bv[keep, :] proposals_3d = proposals_3d[keep, :] proposals_img = proposals_img[keep, :] scores = scores[keep] if debug_state: print ("proposals after nms") print ("proposals_bv shape: ", proposals_bv.shape) print ("proposals_3d shape: ", proposals_3d.shape) # debug only: keep probabilities above a threshold if cfg_in['prob_thresh']: keep_ind = scores[:,0]>cfg_in['prob_thresh'] print ('scores: ',scores) print ('threshold: ', cfg_in['prob_thresh']) print ('score shape:', scores.shape) #print keep_ind.shape #print keep.shape #keep = keep[keep_ind] proposals_bv = proposals_bv[keep_ind, :] proposals_3d = proposals_3d[keep_ind, :] proposals_img = proposals_img[keep_ind, :] scores = scores[keep_ind] return proposals_bv,proposals_3d,proposals_img,scores
def _load_kitti_annotation(self, index): """ Load image and bounding boxes info from txt file in the KITTI format. """ # filename = '$Faster-RCNN_TF/data/KITTI/object/training/label_2/000000.txt' filename = os.path.join(self._data_path, 'training/label_2', index + '.txt') # print("Loading: ", filename) # calib calib = self._load_kitti_calib(index) Tr = calib['Tr_velo2cam'] # print 'Loading: {}'.format(filename) with open(filename, 'r') as f: lines = f.readlines() num_objs = len(lines) translation = np.zeros((num_objs, 3), dtype=np.float32) rys = np.zeros((num_objs), dtype=np.float32) lwh = np.zeros((num_objs, 3), dtype=np.float32) boxes = np.zeros((num_objs, 4), dtype=np.float32) boxes_bv = np.zeros((num_objs, 4), dtype=np.float32) boxes3D = np.zeros((num_objs, 6), dtype=np.float32) boxes3D_lidar = np.zeros((num_objs, 6), dtype=np.float32) boxes3D_cam_cnr = np.zeros((num_objs, 24), dtype=np.float32) boxes3D_corners = np.zeros((num_objs, 24), dtype=np.float32) alphas = np.zeros((num_objs), dtype=np.float32) gt_classes = np.zeros((num_objs), dtype=np.int32) overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32) # print(boxes3D.shape) # Load object bounding boxes into a data frame. ix = -1 for line in lines: obj = line.strip().split(' ') try: cls = self._class_to_ind[obj[0].strip()] # print cls except: continue # ignore objects with undetermined difficult level # level = self._get_obj_level(obj) # if level > 3: # continue ix += 1 # 0-based coordinates alpha = float(obj[3]) x1 = float(obj[4]) y1 = float(obj[5]) x2 = float(obj[6]) y2 = float(obj[7]) h = float(obj[8]) w = float(obj[9]) l = float(obj[10]) tx = float(obj[11]) ty = float(obj[12]) tz = float(obj[13]) ry = float(obj[14]) rys[ix] = ry lwh[ix, :] = [l, w, h] alphas[ix] = alpha translation[ix, :] = [tx, ty, tz] boxes[ix, :] = [x1, y1, x2, y2] boxes3D[ix, :] = [tx, ty, tz, l, w, h] # convert boxes3D cam to 8 corners(cam) boxes3D_cam_cnr_single = computeCorners3D(boxes3D[ix, :], ry) boxes3D_cam_cnr[ix, :] = boxes3D_cam_cnr_single.reshape(24) # convert 8 corners(cam) to 8 corners(lidar) boxes3D_corners[ix, :] = camera_to_lidar_cnr( boxes3D_cam_cnr_single, Tr) # convert 8 corners(cam) to lidar boxes3D boxes3D_lidar[ix, :] = lidar_cnr_to_3d(boxes3D_corners[ix, :], lwh[ix, :]) # convert 8 corners(lidar) to lidar bird view boxes_bv[ix, :] = lidar_3d_to_bv(boxes3D_lidar[ix, :]) # boxes3D_corners[ix, :] = lidar_to_corners_single(boxes3D_lidar[ix, :]) gt_classes[ix] = cls overlaps[ix, cls] = 1.0 rys.resize(ix + 1) lwh.resize(ix + 1, 3) translation.resize(ix + 1, 3) alphas.resize(ix + 1) boxes.resize(ix + 1, 4) boxes_bv.resize(ix + 1, 4) boxes3D.resize(ix + 1, 6) boxes3D_lidar.resize(ix + 1, 6) boxes3D_cam_cnr.resize(ix + 1, 24) boxes3D_corners.resize(ix + 1, 24) gt_classes.resize(ix + 1) # print(self.num_classes) overlaps.resize(ix + 1, self.num_classes) # if index == '000142': # print(index) # print(overlaps) overlaps = scipy.sparse.csr_matrix(overlaps) # if index == '000142': # print(overlaps) return { 'ry': rys, 'lwh': lwh, 'boxes': boxes, 'boxes_bv': boxes_bv, 'boxes_3D_cam': boxes3D, 'boxes_3D': boxes3D_lidar, 'boxes3D_cam_corners': boxes3D_cam_cnr, 'boxes_corners': boxes3D_corners, 'gt_classes': gt_classes, 'gt_overlaps': overlaps, 'xyz': translation, 'alphas': alphas, 'flipped': False }
def _load_kitti_annotation(self, index): """ Load image and bounding boxes info from txt file in the KITTI format. WZN: The non-interested area (Dontcare) is just ignored (treated same as background) """ if self._image_set == 'test': return { 'ry': np.array([]), 'lwh': np.array([]), 'boxes': np.array([]), #xy box in image #'boxes_bv' : boxes_bv, #xy box in bird view 'boxes_3D_cam': np.array([]), #[xyz_center, lwh] in 3D, cam frame #'boxes_3D' : boxes3D_lidar, #[xyz_center, lwh] in 3D, absolute 'boxes3D_cam_corners': np.array([]), #8 corners of box in 3D, cam frame #'boxes_corners' : boxes3D_corners, #8 corners of box in 3D #'boxes_bv_corners' : boxes_bv_corners, #4 corners of box in bird view 'gt_classes': np.array([]), #classes 'gt_overlaps': np.array([]), #default 1, changed later 'xyz': np.array([]), 'alphas': np.array([]), 'diff_level': np.array([]), 'flipped': False } else: # filename = '$Faster-RCNN_TF/data/KITTI/object/training/label_2/000000.txt' filename = os.path.join(self.gt_dir, index + '.txt') # print("Loading: ", filename) # calib calib = self._load_kitti_calib(index) Tr = np.dot(calib['R0'], calib['Tr_velo2cam']) # print 'Loading: {}'.format(filename) with open(filename, 'r') as f: lines = f.readlines() num_objs = len(lines) translation = np.zeros((num_objs, 3), dtype=np.float32) rys = np.zeros((num_objs), dtype=np.float32) lwh = np.zeros((num_objs, 3), dtype=np.float32) boxes = np.zeros((num_objs, 4), dtype=np.float32) boxes_bv = np.zeros((num_objs, 4), dtype=np.float32) boxes3D = np.zeros((num_objs, 6), dtype=np.float32) boxes3D_lidar = np.zeros((num_objs, 6), dtype=np.float32) boxes3D_cam_cnr = np.zeros((num_objs, 24), dtype=np.float32) boxes3D_corners = np.zeros((num_objs, 24), dtype=np.float32) alphas = np.zeros((num_objs), dtype=np.float32) gt_classes = np.zeros((num_objs), dtype=np.int32) overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32) # new difficulty level for in training evaluation diff_level = np.zeros((num_objs), dtype=np.int32) # print(boxes3D.shape) # Load object bounding boxes into a data frame. ix = -1 for line in lines: obj = line.strip().split(' ') try: #WZN.strip() removes white spaces cls = self._class_to_ind[obj[0].strip()] # print cls except: continue # ignore objects with undetermined difficult level level = self._get_obj_level(obj) if level > 3: continue ix += 1 # 0-based coordinates alpha = float(obj[3]) x1 = float(obj[4]) y1 = float(obj[5]) x2 = float(obj[6]) y2 = float(obj[7]) h = float(obj[8]) w = float(obj[9]) l = float(obj[10]) tx = float(obj[11]) ty = float(obj[12]) tz = float(obj[13]) ry = float(obj[14]) diff_level[ix] = level if obj[0].strip() == 'Person_sitting': diff_level[ix] = -1 rys[ix] = ry lwh[ix, :] = [l, w, h] alphas[ix] = alpha translation[ix, :] = [tx, ty, tz] boxes[ix, :] = [x1, y1, x2, y2] boxes3D[ix, :] = [tx, ty, tz, l, w, h] # convert boxes3D cam to 8 corners(cam) boxes3D_cam_cnr_single = computeCorners3D(boxes3D[ix, :], ry) boxes3D_cam_cnr[ix, :] = boxes3D_cam_cnr_single.reshape(24) # convert 8 corners(cam) to 8 corners(lidar) boxes3D_corners[ix, :] = camera_to_lidar_cnr( boxes3D_cam_cnr_single, Tr) # convert 8 corners(cam) to lidar boxes3D, note this is not ivertible because we LOSE ry! boxes3D_lidar[ix, :] = lidar_cnr_to_3d(boxes3D_corners[ix, :], lwh[ix, :]) # convert 8 corners(lidar) to lidar bird view boxes_bv[ix, :] = lidar_3d_to_bv(boxes3D_lidar[ix, :]) # boxes3D_corners[ix, :] = lidar_to_corners_single(boxes3D_lidar[ix, :]) gt_classes[ix] = cls overlaps[ix, cls] = 1.0 rys.resize(ix + 1) lwh.resize(ix + 1, 3) translation.resize(ix + 1, 3) alphas.resize(ix + 1) boxes.resize(ix + 1, 4) boxes_bv.resize(ix + 1, 4) boxes3D.resize(ix + 1, 6) boxes3D_lidar.resize(ix + 1, 6) boxes3D_cam_cnr.resize(ix + 1, 24) boxes3D_corners.resize(ix + 1, 24) boxes_bv_corners = lidar_cnr_to_bv_cnr(boxes3D_corners) gt_classes.resize(ix + 1) # print(self.num_classes) overlaps.resize(ix + 1, self.num_classes) diff_level.resize(ix + 1) # if index == '000142': # print(index) # print(overlaps) overlaps = scipy.sparse.csr_matrix(overlaps) # if index == '000142': # print(overlaps) #if ix>=0: # print index return { 'ry': rys, 'lwh': lwh, 'boxes': boxes, #xy box in image #'boxes_bv' : boxes_bv, #xy box in bird view 'boxes_3D_cam': boxes3D, #[xyz_center, lwh] in 3D, cam frame #'boxes_3D' : boxes3D_lidar, #[xyz_center, lwh] in 3D, absolute 'boxes3D_cam_corners': boxes3D_cam_cnr, #8 corners of box in 3D, cam frame #'boxes_corners' : boxes3D_corners, #8 corners of box in 3D #'boxes_bv_corners' : boxes_bv_corners, #4 corners of box in bird view 'gt_classes': gt_classes, #classes 'gt_overlaps': overlaps, #default 1, changed later 'xyz': translation, 'alphas': alphas, 'diff_level': diff_level, 'flipped': False }