example_np, flow_color_np = sess.run([example, flow_color]) img_id_np = i #example_np['filename'] image_np = example_np['image'] gt_boxes_np = example_np['groundtruth_boxes'] gt_classes_np = example_np['groundtruth_classes'] gt_masks_np = example_np['groundtruth_instance_masks'] height, width = image_np.shape[:2] num_instances_np = gt_masks_np.shape[0] image_np = np.squeeze(image_np) depth_np = example_np['groundtruth_depth'] gt_motions_np = example_np['groundtruth_instance_motions'] composed_flow_color_np, flow_error_np = visualize_flow( depth_np, gt_motions_np, np.ones([gt_motions_np.shape[0]]), example_np['groundtruth_camera_motion'], example_np['camera_intrinsics'], masks=gt_masks_np, groundtruth_flow=example_np['groundtruth_flow']) # motion gt summary gt_rot = np.reshape(gt_motions_np[:, :9], [-1, 3, 3]) gt_trans = np.reshape(gt_motions_np[:, 9:12], [-1, 3]) print(gt_rot.shape) mean_rot_angle = np.mean(np.degrees(_rotation_angle(gt_rot))) mean_trans = np.mean(np.linalg.norm(gt_trans)) print( 'image_id: {}, instances: {}, shape: {}, rot(deg): {}, trans: {}' .format(img_id_np, num_instances_np, image_np.shape, mean_rot_angle, mean_trans))
def visualize_detection_results(result_dict, tag, global_step, categories, summary_dir='', export_dir='', agnostic_mode=False, show_groundtruth=False, min_score_thresh=.5, max_num_predictions=20, sess=None): """Visualizes detection results and writes visualizations to image summaries. This function visualizes an image with its detected bounding boxes and writes to image summaries which can be viewed on tensorboard. It optionally also writes images to a directory. In the case of missing entry in the label map, unknown class name in the visualization is shown as "N/A". Args: result_dict: a dictionary holding groundtruth and detection data corresponding to each image being evaluated. The following keys are required: 'original_image': a numpy array representing the image with shape [1, height, width, 3] 'detection_boxes': a numpy array of shape [N, 4] 'detection_scores': a numpy array of shape [N] 'detection_classes': a numpy array of shape [N] The following keys are optional: 'groundtruth_boxes': a numpy array of shape [N, 4] 'groundtruth_keypoints': a numpy array of shape [N, num_keypoints, 2] Detections are assumed to be provided in decreasing order of score and for display, and we assume that scores are probabilities between 0 and 1. tag: tensorboard tag (string) to associate with image. global_step: global step at which the visualization are generated. categories: a list of dictionaries representing all possible categories. Each dict in this list has the following keys: 'id': (required) an integer id uniquely identifying this category 'name': (required) string representing category name e.g., 'cat', 'dog', 'pizza' 'supercategory': (optional) string representing the supercategory e.g., 'animal', 'vehicle', 'food', etc summary_dir: the output directory to which the image summaries are written. export_dir: the output directory to which images are written. If this is empty (default), then images are not exported. agnostic_mode: boolean (default: False) controlling whether to evaluate in class-agnostic mode or not. show_groundtruth: boolean (default: False) controlling whether to show groundtruth boxes in addition to detected boxes min_score_thresh: minimum score threshold for a box to be visualized max_num_predictions: maximum number of detections to visualize Raises: ValueError: if result_dict does not contain the expected keys (i.e., 'original_image', 'detection_boxes', 'detection_scores', 'detection_classes') """ if not set([ 'original_image', 'detection_boxes', 'detection_scores', 'detection_classes' ]).issubset(set(result_dict.keys())): raise ValueError('result_dict does not contain all expected keys.') if show_groundtruth and 'groundtruth_boxes' not in result_dict: raise ValueError( 'If show_groundtruth is enabled, result_dict must contain ' 'groundtruth_boxes.') logging.info('Creating detection visualizations.') category_index = label_map_util.create_category_index(categories) image = np.squeeze(result_dict['original_image'], axis=0) detection_boxes = result_dict['detection_boxes'] detection_scores = result_dict['detection_scores'] detection_classes = np.int32((result_dict['detection_classes'])) detection_keypoints = result_dict.get('detection_keypoints', None) detection_masks = result_dict.get('detection_masks', None) detection_motions = result_dict.get('detection_motions', None) # Plot groundtruth underneath detections if show_groundtruth: groundtruth_boxes = result_dict['groundtruth_boxes'] groundtruth_keypoints = result_dict.get('groundtruth_keypoints', None) vis_utils.visualize_boxes_and_labels_on_image_array( image, groundtruth_boxes, None, None, category_index, keypoints=groundtruth_keypoints, use_normalized_coordinates=False, max_boxes_to_draw=None) vis_utils.visualize_boxes_and_labels_on_image_array( image, detection_boxes, detection_classes, detection_scores, category_index, instance_masks=detection_masks, keypoints=detection_keypoints, use_normalized_coordinates=False, max_boxes_to_draw=max_num_predictions, min_score_thresh=min_score_thresh, agnostic_mode=agnostic_mode) if export_dir: export_path = os.path.join(export_dir, 'export-{}.png'.format(tag)) vis_utils.save_image_array_as_png(image, export_path) summary_value = [ tf.Summary.Value( tag=tag, image=tf.Summary.Image(encoded_image_string=vis_utils. encode_image_array_as_png_str(image))) ] camera_motion = result_dict.get( 'camera_motion', result_dict.get('groundtruth_camera_motion')) if detection_motions is not None and camera_motion is not None: with sess.as_default(): flow_image, flow_error_image = vis_utils.visualize_flow( result_dict['depth'], detection_motions, detection_scores, camera_motion, result_dict['camera_intrinsics'], masks=detection_masks, groundtruth_flow=result_dict.get('groundtruth_flow'), boxes=detection_boxes, min_score_thresh=min_score_thresh) summary_value.append( tf.Summary.Value(tag=tag + '_flow', image=tf.Summary.Image( encoded_image_string=vis_utils. encode_image_array_as_png_str(flow_image * 255)))) if flow_error_image is not None: summary_value.append( tf.Summary.Value( tag=tag + '_flow_error', image=tf.Summary.Image( encoded_image_string=vis_utils. encode_image_array_as_png_str(flow_error_image * 255)))) summary = tf.Summary(value=summary_value) summary_writer = tf.summary.FileWriter(summary_dir) summary_writer.add_summary(summary, global_step) summary_writer.close() logging.info('Detection visualizations written to summary with tag %s.', tag)