def convert_results(results_path, out_csv_path, method): predictions = torch.load(results_path)['predictions'] predictions = predictions[method] print("Predictions from:", results_path) print("Method:", method) print("Number of predictions: ", len(predictions)) preds = [] for n in tqdm(range(len(predictions))): TCO_n = predictions.poses[n] t = TCO_n[:3, -1] * 1e3 # m -> mm conversion R = TCO_n[:3, :3] row = predictions.infos.iloc[n] obj_id = int(row.label.split('_')[-1]) score = row.score time = row.time pred = dict(scene_id=row.scene_id, im_id=row.view_id, obj_id=obj_id, score=score, t=t, R=R, time=time) preds.append(pred) print("Wrote:", out_csv_path) inout.save_bop_results(out_csv_path, preds) return out_csv_path
def evaluate(self, res_file, out_dir=None, renderer_type='python'): """Evaluates BOP metrics given a result file. Args: res_file: Path to the result file. out_dir: Path to the output directory. renderer_type: Renderer type. 'python' or 'cpp'. Returns: A dictionary holding the results. Raises: RuntimeError: If BOP evaluation failed. """ if out_dir is None: out_dir = self._out_dir ests = inout.load_bop_results(res_file) ests = [self._convert_pose_to_bop(est) for est in ests] res_name = os.path.splitext(os.path.basename(res_file))[0] bop_res_name = 'bop-{}_{}-{}'.format(res_name.replace('_', '-'), self._setup, self._split) bop_res_file = os.path.join(out_dir, "{}.csv".format(bop_res_name)) inout.save_bop_results(bop_res_file, ests) eval_cmd = [ 'python', os.path.join('scripts', 'eval_bop19.py'), '--renderer_type={}'.format(renderer_type), '--result_filenames={}'.format(bop_res_file), '--results_path={}'.format(out_dir), '--eval_path={}'.format(out_dir), ] cwd = "bop_toolkit" env = os.environ.copy() env['PYTHONPATH'] = "." env['BOP_PATH'] = self._bop_dir if subprocess.run(eval_cmd, cwd=cwd, env=env).returncode != 0: raise RuntimeError('BOP evaluation failed.') log_file = os.path.join( out_dir, "bop_eval_{}_{}.log".format(self._name, res_name)) logger = get_logger(log_file) results = {} results['all'] = self._derive_bop_results(out_dir, bop_res_name, False, logger) results['grasp_only'] = self._derive_bop_results( out_dir, bop_res_name, True, logger) logger.info('Evaluation complete.') return results
def tc_to_csv(predictions, csv_path): preds = [] for n in range(len(predictions)): TCO_n = predictions.poses[n] t = TCO_n[:3, -1] * 1e3 # m -> mm conversion R = TCO_n[:3, :3] row = predictions.infos.iloc[n] obj_id = int(row.label.split('_')[-1]) score = row.score time = -1.0 pred = dict(scene_id=row.scene_id, im_id=row.view_id, obj_id=obj_id, score=score, t=t, R=R, time=time) preds.append(pred) inout.save_bop_results(csv_path, preds)
time_spend =time.time()-t1 #ends time for the computation total_inst=0 n_inst = np.sum(inst_counts) else: continue for result_id in sorted_id: total_inst+=1 if(task_type=='2' and total_inst>n_inst): #for vivo task break obj_id = result_objid[result_id] R = result_R[result_id].flatten() t = (result_t[result_id]).flatten() score = result_score[result_id] obj_gt_no = obj_id_targets.index(obj_id) inst_count_est[obj_gt_no]+=1 if(task_type=='2' and inst_count_est[obj_gt_no]>inst_counts[obj_gt_no]): #skip if the result exceeds the amount of taget instances for vivo task continue result_temp ={'scene_id':scene_id,'im_id': im_id,'obj_id':obj_id,'score':score,'R':R,'t':t,'time':time_spend } result_dataset.append(result_temp) if(dataset=='tless'): output_path = os.path.join(output_dir,"pix2pose-iccv19_"+dataset+"-test-primesense.csv") else: output_path = os.path.join(output_dir,"pix2pose-iccv19_"+dataset+"-test.csv") print("Saving the result to ",output_path) inout.save_bop_results(output_path,result_dataset)
aae_start = time.time() pose_est = mp_pose_estimator.process(det, img_masked, cam_K, mm=True) aae_time += (time.time() - aae_start) #pose refinement if pose_refiner_method: # cv2.imshow('depth_mask', depth_masked / depth_img.max()) # cv2.imshow('depth_img', depth_img / depth_img.max()) # cam_K[0,2] = depth_img.shape[1] / 2 # cam_K[1,2] = depth_img.shape[0] / 2 icp_start = time.time() pose_est = pose_refiner.process(pose_est, depth_img=depth_img, camK=cam_K, masks=inst_mask) icp_time += (time.time() - icp_start) if pose_est: img_bop_res.append( convert_rmc2bop(pose_est[0], det[0], scene_id, im_id)) img_pose_ests += pose_est img_dets += det # except: # print((im_id,'not found')) res_path = os.path.join( result_folder, 'sundermeyer-{}_{}-{}.csv'.format(args.eval_name, dataset_name, split)) inout.save_bop_results(res_path, bop_results)
def main(unused_argv): tf.logging.set_verbosity(tf.logging.INFO) # Model folder. model_dir = os.path.join(config.TF_MODELS_PATH, FLAGS.model) # Update flags with parameters loaded from the model folder. common.update_flags(os.path.join(model_dir, common.PARAMS_FILENAME)) # Print the flag values. common.print_flags() # Folder from which the latest model checkpoint will be loaded. checkpoint_dir = os.path.join(model_dir, 'train') # Folder for the inference output. infer_dir = os.path.join(model_dir, 'infer') tf.gfile.MakeDirs(infer_dir) # Folder for the visualization output. vis_dir = os.path.join(model_dir, 'vis') tf.gfile.MakeDirs(vis_dir) # TFRecord files used for training. tfrecord_names = FLAGS.infer_tfrecord_names if not isinstance(FLAGS.infer_tfrecord_names, list): tfrecord_names = [FLAGS.infer_tfrecord_names] # Stride of the final output. if FLAGS.upsample_logits: # The stride is 1 if the logits are upsampled to the input resolution. output_stride = 1 else: assert (len(FLAGS.decoder_output_stride) == 1) output_stride = FLAGS.decoder_output_stride[0] with tf.Graph().as_default(): return_gt_orig = np.any([ FLAGS.task_type == common.LOCALIZATION, FLAGS.vis_gt_poses]) return_gt_maps = np.any([ FLAGS.vis_pred_obj_labels, FLAGS.vis_pred_obj_confs, FLAGS.vis_pred_frag_fields]) # Dataset provider. dataset = datagen.Dataset( dataset_name=FLAGS.dataset, tfrecord_names=tfrecord_names, model_dir=model_dir, model_variant=FLAGS.model_variant, batch_size=1, max_height_before_crop=FLAGS.infer_max_height_before_crop, crop_size=list(map(int, FLAGS.infer_crop_size)), num_frags=FLAGS.num_frags, min_visib_fract=None, gt_knn_frags=1, output_stride=output_stride, is_training=False, return_gt_orig=return_gt_orig, return_gt_maps=return_gt_maps, should_shuffle=False, should_repeat=False, prepare_for_projection=FLAGS.project_to_surface, data_augmentations=None) # Initialize a renderer for visualization. renderer = None if FLAGS.vis_gt_poses or FLAGS.vis_pred_poses: tf.logging.info('Initializing renderer for visualization...') renderer = bop_renderer.Renderer() renderer.init(dataset.crop_size[0], dataset.crop_size[1]) model_type_vis = 'eval' dp_model = dataset_params.get_model_params( config.BOP_PATH, dataset.dataset_name, model_type=model_type_vis) for obj_id in dp_model['obj_ids']: path = dp_model['model_tpath'].format(obj_id=obj_id) renderer.add_object(obj_id, path) tf.logging.info('Renderer initialized.') # Inputs. samples = dataset.get_one_shot_iterator().get_next() # A map from output type to the number of associated channels. outputs_to_num_channels = common.get_outputs_to_num_channels( dataset.num_objs, dataset.model_store.num_frags) # Options of the neural network model. model_options = common.ModelOptions( outputs_to_num_channels=outputs_to_num_channels, crop_size=list(map(int, FLAGS.infer_crop_size)), atrous_rates=FLAGS.atrous_rates, encoder_output_stride=FLAGS.encoder_output_stride) # Construct the inference graph. predictions = model.predict( images=samples[common.IMAGE], model_options=model_options, upsample_logits=FLAGS.upsample_logits, image_pyramid=FLAGS.image_pyramid, num_objs=dataset.num_objs, num_frags=dataset.num_frags, frag_cls_agnostic=FLAGS.frag_cls_agnostic, frag_loc_agnostic=FLAGS.frag_loc_agnostic) # Global step. tf.train.get_or_create_global_step() # Get path to the model checkpoint. if FLAGS.checkpoint_name is None: checkpoint_path = tf.train.latest_checkpoint(checkpoint_dir) else: checkpoint_path = os.path.join(checkpoint_dir, FLAGS.checkpoint_name) time_str = time.strftime('%Y-%m-%d-%H:%M:%S', time.gmtime()) tf.logging.info('Starting inference at: {}'.format(time_str)) tf.logging.info('Inference with model: {}'.format(checkpoint_path)) # Scaffold for initialization. scaffold = tf.train.Scaffold( init_op=tf.global_variables_initializer(), saver=tf.train.Saver(var_list=misc.get_variable_dict())) # TensorFlow configuration. if FLAGS.cpu_only: tf_config = tf.ConfigProto(device_count={'GPU': 0}) else: tf_config = tf.ConfigProto() # tf_config.gpu_options.allow_growth = True # Only necessary GPU memory. tf_config.gpu_options.allow_growth = False # Nodes that can use multiple threads to parallelize their execution will # schedule the individual pieces into this pool. tf_config.intra_op_parallelism_threads = 10 # All ready nodes are scheduled in this pool. tf_config.inter_op_parallelism_threads = 10 poses_all = [] first_im_poses_num = 0 session_creator = tf.train.ChiefSessionCreator( config=tf_config, scaffold=scaffold, master=FLAGS.master, checkpoint_filename_with_path=checkpoint_path) with tf.train.MonitoredSession( session_creator=session_creator, hooks=None) as sess: im_ind = 0 while not sess.should_stop(): # Estimate object poses for the current image. poses, run_times = process_image( sess=sess, samples=samples, predictions=predictions, im_ind=im_ind, crop_size=dataset.crop_size, output_scale=(1.0 / output_stride), model_store=dataset.model_store, renderer=renderer, task_type=FLAGS.task_type, infer_name=FLAGS.infer_name, infer_dir=infer_dir, vis_dir=vis_dir) # Note that the first image takes longer time (because of TF init). tf.logging.info( 'Image: {}, prediction: {:.3f}, establish_corr: {:.3f}, ' 'fitting: {:.3f}, total time: {:.3f}'.format( im_ind, run_times['prediction'], run_times['establish_corr'], run_times['fitting'], run_times['total'])) poses_all += poses if im_ind == 0: first_im_poses_num = len(poses) im_ind += 1 # Set the time of pose estimates from the first image to the average time. # Tensorflow takes a long time on the first image (because of init). time_avg = 0.0 for pose in poses_all: time_avg += pose['time'] if len(poses_all) > 0: time_avg /= float((len(poses_all))) for i in range(first_im_poses_num): poses_all[i]['time'] = time_avg # Save the estimated poses in the BOP format: # https://bop.felk.cvut.cz/challenges/bop-challenge-2020/#formatofresults if FLAGS.save_estimates: suffix = '' if FLAGS.infer_name is not None: suffix = '_{}'.format(FLAGS.infer_name) poses_path = os.path.join( infer_dir, 'estimated-poses{}.csv'.format(suffix)) tf.logging.info('Saving estimated poses to: {}'.format(poses_path)) inout.save_bop_results(poses_path, poses_all, version='bop19') time_str = time.strftime('%Y-%m-%d-%H:%M:%S', time.gmtime()) tf.logging.info('Finished inference at: {}'.format(time_str))