def load_dataset(self, path_to_dataset):
"""
Load the features .pgz file and parse it into the class variables
"""
inputs = []
labels = []
# creating groups for stratified validation (all 10-minute file from a specific
# hour can only be or in training set or in validation set)
groups = []
print "Loading dataset using features " + str(self.selected_features) + "..",
# [file_name][feature_name][epoch][..] or
# [file_name][state/hour]
dataset_dict = load_zipped_pickle(path_to_dataset)
for file in dataset_dict:
for input in dataset_dict[file][self.selected_features]:
inputs.append(input)
labels.append(dataset_dict[file]['state'])
groups.append(dataset_dict[file]['hour'])
print(" done.")
return(np.array(inputs), np.array(labels), np.array(groups))
def __init__(self, classes, npoints, center_perturbation, size_perturbation, angle_perturbation,
classes_to_drop=[], classes_to_drop_prob=0, random_flip=False, random_shift=False, rotate_to_center=False, overwritten_data_path=None):
self.classes = classes
self.npoints = npoints
self.random_flip = random_flip
self.random_shift = random_shift
self.rotate_to_center = rotate_to_center
self.center_perturbation = center_perturbation
self.size_perturbation = size_perturbation
self.angle_perturbation = angle_perturbation
self.prepared_batches = deque()
assert(overwritten_data_path is not None)
idx_l, box2d_l, box3d_l, image_crop_l, points_l, label_l, cls_type_l, heading_l, size_l, \
rtilt_l, k_l, frustum_angle_l, img_dims_l = load_zipped_pickle(overwritten_data_path)
# Maps cls_type to it's idx within (self.label_2Dl, self.heading_2Dl, etc) to allow class-wise sampling
self.cls_to_idx_map = {}
# Filtering out classes that we do not want
self.idx_l, self.box2d_l, self.box3d_l, self.image_crop_l, self.points_l, self.label_l, \
self.cls_type_l, self.heading_l, self.size_l, self.rtilt_l, self.k_l, \
self.frustum_angle_l, self.img_dims_l = [], [], [], [], [], [], [], [], [], [], [], [], []
np.random.seed(20)
cls_idx = 0
for idx, box2d, box3d, image_crop, points, label, cls_type, heading, size, rtilt, k, \
frustum_angle, img_dims in zip(idx_l, box2d_l, box3d_l, image_crop_l, points_l, \
label_l, cls_type_l, heading_l, size_l, rtilt_l, k_l, frustum_angle_l, img_dims_l):
if cls_type in self.classes:
if cls_type in classes_to_drop and (np.random.rand() < classes_to_drop_prob):
continue
if self.cls_to_idx_map.get(cls_type) is None:
self.cls_to_idx_map[cls_type] = [cls_idx]
else:
self.cls_to_idx_map[cls_type].append(cls_idx)
cls_idx += 1
self.idx_l.append(idx)
self.box2d_l.append(box2d)
self.box3d_l.append(box3d)
#self.image_crop_l.append(image_crop)
self.points_l.append(points)
self.label_l.append(label)
self.cls_type_l.append(cls_type)
self.heading_l.append(heading)
self.size_l.append(size)
self.rtilt_l.append(rtilt)
self.k_l.append(k)
self.frustum_angle_l.append(frustum_angle)
self.img_dims_l.append(img_dims)
def load_dataset(self, path_to_dataset):
"""
Load the features .pgz file and parse it into the class variables
"""
inputs = []
file_names = []
print "Loading testset using features " + str(self.selected_features) + "..",
# [file_name][feature_name][epoch][..] and
# [file_name][state/hour]
dataset_dict = load_zipped_pickle(path_to_dataset)
for file in dataset_dict:
inputs.append(dataset_dict[file][self.selected_features])
file_names.append(file)
print(" done.")
return(np.array(inputs), np.array(file_names))
VISU = FLAGS.viz
if VISU:
import mayavi.mlab as mlab
from view_pc import draw_lidar, draw_gt_boxes3d
#with open(FLAGS.result_path, 'rb') as fp:
# ps_list = pickle.load(fp)
# segp_list = pickle.load(fp)
# center_list = pickle.load(fp)
# heading_cls_list = pickle.load(fp)
# heading_res_list = pickle.load(fp)
# size_cls_list = pickle.load(fp)
# size_res_list = pickle.load(fp)
# rot_angle_list = pickle.load(fp)
# score_list = pickle.load(fp)
ps_list, segp_list, center_list, heading_cls_list, heading_res_list, size_cls_list, size_res_list, rot_angle_list, score_list = load_zipped_pickle(
FLAGS.result_path)
total_cnt = 0
correct_cnt = 0
type_whitelist = [
'bed', 'table', 'sofa', 'chair', 'toilet', 'desk', 'dresser',
'night_stand', 'bookshelf', 'bathtub'
]
class_correct_cnt = {classname: 0 for classname in type_whitelist}
class_total_cnt = {classname: 0 for classname in type_whitelist}
for i in range(len(segp_list)):
print " ---- %d/%d" % (i, len(segp_list))
img_id = TEST_DATASET.id_list[i]
box2d = TEST_DATASET.box2d_list[i]
classname = TEST_DATASET.type_list[i]
def vis_predictions3D(pred_files, gt_file, number_to_show=10, filenums=None):
from roi_seg_box3d_dataset import class2type
idx = 0
COLS = number_to_show
ap_infos = {}
classes, file_nums, mean_box_ious, mean_seg_ious, box_ious, seg_ious = [], [], [], [], [], []
vtk_pcs_with_col, vtk_pcs_wo_col, vtk_imgs, vtk_gt_boxes, vtk_pred_boxes, vtk_texts = [], [], [], [], [], []
choices = []
test_dataset = ROISegBoxDataset(WHITE_LIST, npoints=2048,
split='val', rotate_to_center=True,
overwritten_data_path=gt_file,
from_rgb_detection=False)
for n, pred_file in enumerate(pred_files):
# Lists of different items from predictions
predictions = load_zipped_pickle(pred_file)
ps_l, seg_gt_l, seg_pred_l, center_l, heading_cls_l, heading_res_l, size_cls_l, size_res_l, rot_angle_l, \
score_l, cls_type_l, file_num_l, box2d_l, box3d_l = predictions
if n == 0:
# Choosing equal number of objects per class to display
cls_types = []
options = {}
for i, cls_type in enumerate(cls_type_l):
if not class2type[cls_type] in WHITE_LIST: continue
if options.get(cls_type) is None:
options[cls_type] = [i]
cls_types.append(cls_type)
else:
options[cls_type].append(i)
# Make use of array_split to divide into fairly equal groups
arr = np.array_split([1] * number_to_show, len(options.keys()))
random.shuffle(arr)
for i, group in enumerate(arr):
cls_type = cls_types[i]
choice_list = np.random.choice(options[cls_type], len(group), replace=False) #replace=True)
choices.extend(choice_list)
print('Number of objects in whitelist: %d' % len(options))
# Compute overall statistics
if not FLAGS.rgb_detection:
print('==== Computing overall statistics for %s ====' % pred_file)
from evaluate import evaluate_predictions, get_ap_info
rec, prec, ap, mean_ap = evaluate_predictions(predictions, dataset, CLASSES,
test_dataset, WHITE_LIST)
ap['Mean AP'] = mean_ap
for classname in ap.keys():
if ap_infos.get(classname) is None: ap_infos[classname] = []
ap_infos[classname].append('%11s: [%.1f]' % (classname, 100. * ap[classname]))
box_iou_sum, seg_iou_sum = 0, 0
for i in range(len(ps_l)):
seg_gt = seg_gt_l[i]
box3d = box3d_l[i]
seg_pred = seg_pred_l[i]
center = center_l[i]
heading_cls = heading_cls_l[i]
heading_res = heading_res_l[i]
size_cls = size_cls_l[i]
size_res = size_res_l[i]
rot_angle = rot_angle_l[i]
gt_box3d = rotate_pc_along_y(np.copy(box3d), rot_angle)
heading_angle = class2angle(heading_cls, heading_res, NUM_HEADING_BIN)
box_size = class2size(size_cls, size_res)
pred_box3d = get_3d_box(box_size, heading_angle, center)
# Box IOU
shift_arr = np.array([4,5,6,7,0,1,2,3])
box_iou3d, _ = box3d_iou(gt_box3d[shift_arr,:], pred_box3d)
# Seg IOU
seg_iou = get_seg_iou(seg_gt, seg_pred, 2)
box_iou_sum += box_iou3d
seg_iou_sum += seg_iou
mean_box_iou = box_iou_sum / len(ps_l)
mean_seg_iou = seg_iou_sum / len(ps_l)
mean_box_ious.append(mean_box_iou)
mean_seg_ious.append(mean_seg_iou)
for i in choices:
row, col = idx // COLS, idx % COLS
idx += 1
ps = ps_l[i]
seg_pred = seg_pred_l[i]
center = center_l[i]
heading_cls = heading_cls_l[i]
heading_res = heading_res_l[i]
size_cls = size_cls_l[i]
size_res = size_res_l[i]
rot_angle = rot_angle_l[i]
score = score_l[i]
cls_type = cls_type_l[i]
file_num = file_num_l[i]
seg_gt = seg_gt_l[i] if not FLAGS.rgb_detection else []
box2d = box2d_l[i]
box3d = box3d_l[i] if not FLAGS.rgb_detection else []
# Visualize point cloud (with and without color)
vtk_pc_wo_col = vis.VtkPointCloud(ps)
vtk_pc = vis.VtkPointCloud(ps, gt_points=seg_gt, pred_points=seg_pred)
vis.vtk_transform_actor(vtk_pc_wo_col.vtk_actor, translate=(SEP*col,SEP*row,0))
vis.vtk_transform_actor(vtk_pc.vtk_actor, translate=(SEP*col,SEP*row,0))
vtk_pcs_wo_col.append(vtk_pc_wo_col.vtk_actor)
vtk_pcs_with_col.append(vtk_pc.vtk_actor)
# Visualize GT 3D box
if FLAGS.rgb_detection:
objects = dataset.get_label_objects(file_num)
calib = dataset.get_calibration(file_num)
for obj in objects:
if obj.classname not in WHITE_LIST: continue
box3d_pts_2d, box3d_pts_3d = compute_box_3d(obj, calib)
box3d_pts_3d = calib.project_upright_depth_to_upright_camera(box3d_pts_3d)
box3d_pts_3d = rotate_pc_along_y(np.copy(box3d_pts_3d), rot_angle)
vtk_box3D = vis.vtk_box_3D(box3d_pts_3d, color=vis.Color.LightGreen)
vis.vtk_transform_actor(vtk_box3D, translate=(SEP*col,SEP*row,0))
vtk_gt_boxes.append(vtk_box3D)
else:
gt_box3d = rotate_pc_along_y(np.copy(box3d), rot_angle)
vtk_gt_box3D = vis.vtk_box_3D(gt_box3d, color=vis.Color.LightGreen)
vis.vtk_transform_actor(vtk_gt_box3D, translate=(SEP*col,SEP*row,0))
vtk_gt_boxes.append(vtk_gt_box3D)
# Visualize Pred 3D box
heading_angle = class2angle(heading_cls, heading_res, NUM_HEADING_BIN)
box_size = class2size(size_cls, size_res)
pred_box3d = get_3d_box(box_size, heading_angle, center)
vtk_pred_box3D = vis.vtk_box_3D(pred_box3d, color=vis.Color.White)
vis.vtk_transform_actor(vtk_pred_box3D, translate=(SEP*col,SEP*row,0))
vtk_pred_boxes.append(vtk_pred_box3D)
# Visualize Images
box2d_col = vis.Color.LightGreen if not FLAGS.rgb_detection else vis.Color.Orange
img_filename = os.path.join(IMG_DIR, '%06d.jpg' % file_num)
vtk_img = vis.vtk_image(img_filename, box2Ds_list=[[box2d]], box2Ds_cols=[box2d_col])
vis.vtk_transform_actor(vtk_img, scale=(IMG_SCALE,IMG_SCALE,IMG_SCALE),
rot=(0,180,180), translate=(-2+SEP*col,2+SEP*row,10))
vtk_imgs.append(vtk_img)
# Other information
classes.append(class2type[cls_type].capitalize())
file_nums.append(str(file_num))
if not FLAGS.rgb_detection:
shift_arr = np.array([4,5,6,7,0,1,2,3])
box_iou3d, _ = box3d_iou(gt_box3d[shift_arr,:], pred_box3d)
box_ious.append(box_iou3d)
seg_iou = get_seg_iou(seg_gt, seg_pred, 2)
seg_ious.append(seg_iou)
# Visualize overall statistics
vtk_texts.extend(vis.vtk_text([('Model: %s' % pred_file.split('/')[-1]) for pred_file in pred_files], arr_type='text', sep=SEP, cols=1, scale=TEXT_SCALE, rot=TEXT_ROT, translate=(-14.5,2.5,2)))
vtk_texts.extend(vis.vtk_text(['Mean Box IOU:'] * len(pred_files), arr_type='text', sep=SEP, cols=1, scale=TEXT_SCALE, rot=TEXT_ROT, translate=(-14.5,3,2)))
vtk_texts.extend(vis.vtk_text(mean_box_ious, arr_type='float', color=True, sep=SEP, cols=1, scale=TEXT_SCALE, rot=TEXT_ROT, translate=(-10,3,2)))
vtk_texts.extend(vis.vtk_text(['Mean Seg IOU:'] * len(pred_files), arr_type='text', sep=SEP, cols=1, scale=TEXT_SCALE, rot=TEXT_ROT, translate=(-14.5,3.5,2)))
vtk_texts.extend(vis.vtk_text(mean_seg_ious, arr_type='float', color=True, sep=SEP, cols=1, scale=TEXT_SCALE, rot=TEXT_ROT, translate=(-10,3.5,2)))
for i, (cls_name, ap_info) in enumerate(ap_infos.items()):
vtk_texts.extend(vis.vtk_text(ap_info, arr_type='text', color=True, sep=SEP, cols=1, scale=TEXT_SCALE, rot=TEXT_ROT, translate=(-14.5,4+i*0.5,2)))
# Visualize text information
vtk_texts.extend(vis.vtk_text(['Class:'] * len(classes), arr_type='text', sep=SEP, cols=COLS, scale=TEXT_SCALE, rot=TEXT_ROT, translate=(-1.5,3,2)))
vtk_texts.extend(vis.vtk_text(classes, arr_type='text', sep=SEP, cols=COLS, scale=TEXT_SCALE, rot=TEXT_ROT, translate=(0.5,3,2)))
vtk_texts.extend(vis.vtk_text(['File:'] * len(file_nums), arr_type='text', sep=SEP, cols=COLS, scale=TEXT_SCALE, rot=TEXT_ROT, translate=(-1.5,3.5,2)))
vtk_texts.extend(vis.vtk_text(file_nums, arr_type='text', sep=SEP, cols=COLS, scale=TEXT_SCALE, rot=TEXT_ROT, translate=(0.25,3.5,2)))
if not FLAGS.rgb_detection:
vtk_texts.extend(vis.vtk_text(['Box:'] * len(box_ious), arr_type='text', sep=SEP, cols=COLS, scale=TEXT_SCALE, rot=TEXT_ROT, translate=(-1.5,4,2)))
vtk_texts.extend(vis.vtk_text(box_ious, arr_type='float', color=True, sep=SEP, cols=COLS, scale=TEXT_SCALE, rot=TEXT_ROT, translate=(0,4,2)))
vtk_texts.extend(vis.vtk_text(['Seg:'] * len(seg_ious), arr_type='text', sep=SEP, cols=COLS, scale=TEXT_SCALE, rot=TEXT_ROT, translate=(-1.5,4.5,2)))
vtk_texts.extend(vis.vtk_text(seg_ious, arr_type='float', color=True, sep=SEP, cols=COLS, scale=TEXT_SCALE, rot=TEXT_ROT, translate=(0,4.5,2)))
key_to_actors_to_hide = { 'g': vtk_gt_boxes, 'p': vtk_pred_boxes, 'i': vtk_imgs, 'c': vtk_pcs_wo_col, 't': vtk_texts }
return vtk_pcs_with_col, key_to_actors_to_hide
VISU = FLAGS.viz
if VISU:
import mayavi.mlab as mlab
from view_pc import draw_lidar, draw_gt_boxes3d
#with open(FLAGS.result_path, 'rb') as fp:
# ps_list = pickle.load(fp)
# segp_list = pickle.load(fp)
# center_list = pickle.load(fp)
# heading_cls_list = pickle.load(fp)
# heading_res_list = pickle.load(fp)
# size_cls_list = pickle.load(fp)
# size_res_list = pickle.load(fp)
# rot_angle_list = pickle.load(fp)
# score_list = pickle.load(fp)
ps_list, segp_list, center_list, heading_cls_list, heading_res_list, size_cls_list, size_res_list, rot_angle_list, score_list = load_zipped_pickle(FLAGS.result_path)
total_cnt = 0
correct_cnt = 0
type_whitelist=['bed','table','sofa','chair','toilet','desk','dresser','night_stand','bookshelf','bathtub']
class_correct_cnt = {classname:0 for classname in type_whitelist}
class_total_cnt = {classname:0 for classname in type_whitelist}
for i in range(len(segp_list)):
print " ---- %d/%d"%(i,len(segp_list))
img_id = TEST_DATASET.id_list[i]
box2d = TEST_DATASET.box2d_list[i]
classname = TEST_DATASET.type_list[i]
objects = dataset.get_label_objects(img_id)
target_obj = None
for obj in objects: # **Assuming we use GT box2d for 3D box estimation evaluation**
def __init__(self, npoints, split, random_flip=False, random_shift=False, rotate_to_center=False, overwritten_data_path=None, from_rgb_detection=False, one_hot=False):
self.npoints = npoints
self.random_flip = random_flip
self.random_shift = random_shift
self.rotate_to_center = rotate_to_center
self.one_hot = one_hot
if overwritten_data_path is None:
overwritten_data_path = os.path.join(BASE_DIR, '%s_1002.zip.pickle'%(split))
self.from_rgb_detection = from_rgb_detection
if from_rgb_detection:
self.id_list, self.box2d_list, self.input_list, self.type_list, self.frustum_angle_list, self.prob_list = load_zipped_pickle(overwritten_data_path)
else:
self.id_list,self.box2d_list,self.box3d_list,self.input_list,self.label_list,self.type_list,self.heading_list,self.size_list,self.frustum_angle_list=load_zipped_pickle(overwritten_data_path)
def __init__(self,
classes,
npoints,
split,
classes_to_drop=[],
classes_to_drop_prob=0,
random_flip=False,
random_shift=False,
rotate_to_center=False,
overwritten_data_path=None,
from_rgb_detection=False,
one_hot=False):
self.classes = classes
self.npoints = npoints
self.random_flip = random_flip
self.random_shift = random_shift
self.rotate_to_center = rotate_to_center
self.one_hot = one_hot
assert (not overwritten_data_path is None)
self.from_rgb_detection = from_rgb_detection
if from_rgb_detection:
idx_l, box2d_l, image_crop_l, points_l, cls_type_l, frustum_angle_l, prob_l = \
load_zipped_pickle(overwritten_data_path)
# Filtering out classes that we do not want
self.idx_l, self.box2d_l, self.image_crop_l, self.points_l, self.cls_type_l, \
self.frustum_angle_l, self.prob_l = [], [], [], [], [], [], []
for idx, box2d, image_crop, points, cls_type, frustum_angle, prob in \
zip(idx_l, box2d_l, image_crop_l, points_l, cls_type_l, frustum_angle_l, prob_l):
if cls_type in self.classes:
self.idx_l.append(idx)
self.box2d_l.append(box2d)
self.image_crop_l.append(image_crop)
self.points_l.append(points)
self.cls_type_l.append(cls_type)
self.frustum_angle_l.append(frustum_angle)
self.prob_l.append(prob)
else:
idx_l, box2d_l, box3d_l, image_crop_l, points_l, label_l, cls_type_l, heading_l, size_l, \
rtilt_l, k_l, frustum_angle_l, img_dims_l = load_zipped_pickle(overwritten_data_path)
# Filtering out classes that we do not want
self.idx_l, self.box2d_l, self.box3d_l, self.image_crop_l, self.points_l, self.label_l, \
self.cls_type_l, self.heading_l, self.size_l, self.rtilt_l, self.k_l, \
self.frustum_angle_l, self.img_dims_l = [], [], [], [], [], [], [], [], [], [], [], [], []
for idx, box2d, box3d, image_crop, points, label, cls_type, heading, size, rtilt, k, \
frustum_angle, img_dims in zip(idx_l, box2d_l, box3d_l, image_crop_l, points_l, \
label_l, cls_type_l, heading_l, size_l, rtilt_l, k_l, frustum_angle_l, img_dims_l):
if cls_type in self.classes:
if cls_type in classes_to_drop and (np.random.rand() <
classes_to_drop_prob):
continue
self.idx_l.append(idx)
self.box2d_l.append(box2d)
self.box3d_l.append(box3d)
self.image_crop_l.append(image_crop)
self.points_l.append(points)
self.label_l.append(label)
self.cls_type_l.append(cls_type)
self.heading_l.append(heading)
self.size_l.append(size)
self.rtilt_l.append(rtilt)
self.k_l.append(k)
self.frustum_angle_l.append(frustum_angle)
self.img_dims_l.append(img_dims)
for age, task_idx in enumerate(range(nb_tasks)):
print("Age is {}".format(age))
X_train, y_train = training_data[task_idx]
cl.pre_task_updates()
cl.fit(X_train, y_train, protocol['epochs_per_task'])
ftask = []
for X_valid, y_valid in valid_data[:task_idx + 1]:
f_ = cl.evaluate(X_valid, y_valid)
ftask.append(f_)
print(np.mean(ftask))
evals.append(ftask)
next_task = True if task_idx != nb_tasks - 1 else False
cl.post_task_updates(X_train, y_train, next_task=next_task)
return evals, tmp_evals
total_evals = []
evals, tmp_evals = run_fits(training_dataset, validation_dataset)
print([np.mean(e) for e in evals])
print([np.mean(e) for e in tmp_evals])
utils.save_zipped_pickle(evals, datafile_name)
evals = utils.load_zipped_pickle(datafile_name)
def __init__(self,
classes3D,
classes2D,
npoints,
data3D_keep_prob=1,
add3D_for_classes2D_prob=0,
random_flip=False,
random_shift=False,
rotate_to_center=False,
overwritten_data_path=None):
# Classes3D are the classes that we want the 3D bounding boxes of while
# Classes2D are the classes that we want the 2D bounding boxes of.
self.classes3D = classes3D
self.classes2D = classes2D
self.npoints = npoints
self.random_flip = random_flip
self.random_shift = random_shift
self.rotate_to_center = rotate_to_center
assert (overwritten_data_path is not None)
idx_l, box2d_l, box3d_l, image_crop_l, points_l, label_l, cls_type_l, heading_l, size_l, \
rtilt_l, k_l, frustum_angle_l, img_dims_l = load_zipped_pickle(overwritten_data_path)
# Maps cls_type to it's idx within (self.label_3Dl, self.heading_3Dl, etc) to allow class-wise sampling
self.cls_to_idx_map3D = {}
# Choosing the Classes to provide 3D bounding boxes for
self.idx_3Dl, self.box2d_3Dl, self.box3d_3Dl, self.image_crop_3Dl, self.points_3Dl, self.label_3Dl, \
self.cls_type_3Dl, self.heading_3Dl, self.size_3Dl, self.rtilt_3Dl, self.k_3Dl, \
self.frustum_angle_3Dl, self.img_dims_3Dl = [], [], [], [], [], [], [], [], [], [], [], [], []
# Maps cls_type to it's idx within (self.label_2Dl, self.heading_2Dl, etc) to allow class-wise sampling
self.cls_to_idx_map2D = {}
# Choosing the Classes to only provide 2D bounding boxes for
self.idx_2Dl, self.box2d_2Dl, self.box3d_2Dl, self.image_crop_2Dl, self.points_2Dl, self.label_2Dl, \
self.cls_type_2Dl, self.heading_2Dl, self.size_2Dl, self.rtilt_2Dl, self.k_2Dl, \
self.frustum_angle_2Dl, self.img_dims_2Dl = [], [], [], [], [], [], [], [], [], [], [], [], []
np.random.seed(20)
cls3D_idx, cls2D_idx = 0, 0
for idx, box2d, box3d, image_crop, points, label, cls_type, heading, size, rtilt, k, \
frustum_angle, img_dims in zip(idx_l, box2d_l, box3d_l, image_crop_l, points_l, \
label_l, cls_type_l, heading_l, size_l, rtilt_l, k_l, frustum_angle_l, img_dims_l):
if (cls_type in self.classes3D and (np.random.rand() <= data3D_keep_prob)) or \
(np.random.rand() < add3D_for_classes2D_prob):
if self.cls_to_idx_map3D.get(cls_type) is None:
self.cls_to_idx_map3D[cls_type] = [cls3D_idx]
else:
self.cls_to_idx_map3D[cls_type].append(cls3D_idx)
cls3D_idx += 1
self.idx_3Dl.append(idx)
self.box2d_3Dl.append(box2d)
self.box3d_3Dl.append(box3d)
#self.image_crop_3Dl.append(image_crop)
self.points_3Dl.append(points)
self.label_3Dl.append(label)
self.cls_type_3Dl.append(cls_type)
self.heading_3Dl.append(heading)
self.size_3Dl.append(size)
self.rtilt_3Dl.append(rtilt)
self.k_3Dl.append(k)
self.frustum_angle_3Dl.append(frustum_angle)
self.img_dims_3Dl.append(img_dims)
if self.classes2D is not None and cls_type in self.classes2D:
if self.cls_to_idx_map2D.get(cls_type) is None:
self.cls_to_idx_map2D[cls_type] = [cls2D_idx]
else:
self.cls_to_idx_map2D[cls_type].append(cls2D_idx)
cls2D_idx += 1
self.idx_2Dl.append(idx)
self.box2d_2Dl.append(box2d)
self.box3d_2Dl.append(box3d)
#self.image_crop_2Dl.append(image_crop)
self.points_2Dl.append(points)
self.label_2Dl.append(label)
self.cls_type_2Dl.append(cls_type)
self.heading_2Dl.append(heading)
self.size_2Dl.append(size)
self.rtilt_2Dl.append(rtilt)
self.k_2Dl.append(k)
self.frustum_angle_2Dl.append(frustum_angle)
self.img_dims_2Dl.append(img_dims)
sorted_keys = ap.keys()
sorted_keys.sort()
for classname in sorted_keys:
string += ('%11s: [%.1f]\n' % (classname, 100. * ap[classname]))
string += (' Mean AP: %.1f' % (100. * mean_ap))
return string
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--gt_path', default=None, help='GT path for .pickle file, the one used for val in train.py [default: None]')
parser.add_argument('--pred_path', default=None, help='Prediction path for .pickle file from test.py [default: None]')
FLAGS = parser.parse_args()
CLASSES = ['bed','table','sofa','chair','toilet','desk','dresser','night_stand','bookshelf','bathtub']
TEST_CLASSES = ['table','sofa','dresser','night_stand','bookshelf'] #['bed','chair','toilet','desk','bathtub']
SUNRGBD_DATASET_DIR = '/home/yewsiang/Transferable3D/dataset/mysunrgbd'
IMG_DIR = pjoin(SUNRGBD_DATASET_DIR, 'training', 'image')
# Load GT
TEST_DATASET = roi_seg_box3d_dataset.ROISegBoxDataset(TEST_CLASSES, npoints=2048,
split='val', rotate_to_center=True,
overwritten_data_path=FLAGS.gt_path,
from_rgb_detection=False)
DATASET = sunrgbd_object(SUNRGBD_DATASET_DIR, 'training')
# Load predictions
predictions = load_zipped_pickle(FLAGS.pred_path)
rec, prec, ap, mean_ap = evaluate_predictions(predictions, DATASET, CLASSES, TEST_DATASET, TEST_CLASSES)
print(get_ap_info(ap, mean_ap))
plot_ap(ap)