def main(): detector = Detector(net_id=NET_ARCH, labels_net_arch=LABELS_NET, labels_output=LABELS_OUT) rgb_files = _read_rgb_filenames(DATASET_DIR) rgb_files.sort() label_map = load_labels(LABELS_OUT) for idx, img_path in enumerate(rgb_files): print("\r[ %d / %d ] Processing %s" % (idx, len(rgb_files), os.path.basename(img_path)), end='', flush=True) img_rgb = np.array(Image.open(img_path)) # run inference obj_detected = detector.run_inference_on_img(img_rgb) classes_remapped, scores_remapped, boxes_remapped = detector.remap_labels( obj_detected.classes, obj_detected.scores, obj_detected.boxes) if len(boxes_remapped) > 0: classes_remapped = np.squeeze(classes_remapped, axis=0) boxes_remapped = np.squeeze(boxes_remapped, axis=0) scores_remapped = np.squeeze(scores_remapped, axis=0) _create_xml_pascal(img_path, img_rgb, classes_remapped, boxes_remapped, label_map)
def __init__(self, flags): # Set all flags self.flags = flags # Load all file names self.files = read_filenames(flags.dataset_dir, flags.filter_keywords, flags.main_sensor, flags.aux_sensor, 'png') # Load frozen rgb detector to create annotations self._detector = Detector(net_id=flags.net_arch, arch_config=flags.arch_config, labels_net_arch=flags.labels_net, labels_output=flags.labels_out, retrieval_thresh=flags.retrieval_thresh) # Encoder for tfrecords self.labels = load_labels(flags.labels_out) self._encoder = EncoderTFrecGoogleApi() self.output = os.path.join(flags.output_dir, flags.tfrecord_name_prefix + ".tfrecord") # Initialize filter self._learning_filter = LearningFilter( score_threshold=flags.lf_score_thresh, min_img_perimeter=flags.min_obj_size, logstats=True, mode=self.flags.lf_mode, verbose=self.flags.verbose) # Analyze the dataset self._analysis = self._analyze_dataset(flags, self.files) # Image Stats self._encoded_mean = [] self._encoded_std = []
def visualize(): """ Takes in images and xml labels in PASCAL VOC format. They must have the same filenames. Visualizes the bounding boxes on the images and saves them in the output folder. :return: """ image_files = [ f for f in os.listdir(IMG_INPUT_DIR) if f.endswith(".png") and all(key in f for key in FILTER_KEYWORDS) ] image_files.sort() xml_files = [f for f in os.listdir(XML_INPUT_DIR) if f.endswith(".xml")] xml_files.sort() classes = load_labels(LABEL_MAP) class_names = { classes[i]['name']: i for i in list(range(1, len(classes) + 1)) } if not os.path.isdir(OUTPUT_DIR): os.makedirs(OUTPUT_DIR) for idx, (img_name, xml_name) in enumerate(zip(image_files, xml_files)): # Parse XML Files xml_file = os.path.join(XML_INPUT_DIR, xml_name) xml_tree = ET.parse(xml_file).getroot() xml_data = _recursive_parse_xml_to_dict(xml_tree) # Create tfRecord dict instance img_file = os.path.join(IMG_INPUT_DIR, img_name) instance = dict_to_tf_instance(xml_data['annotation'], img_file, class_names) visualize_boxes_and_labels_on_image_array( instance['image'], instance['boxes'], instance['labels'], None, classes, use_normalized_coordinates=True, line_thickness=2) # Show Output if VERBOSE: cv2.imshow('Visualization', cv2.cvtColor(instance['image'], cv2.COLOR_BGR2RGB)) cv2.waitKey(5) print("\r[ %d / %d ] Processing %s" % (idx + 1, len(image_files), os.path.basename(img_file)), end='') # Save image as png output_file = os.path.join(OUTPUT_DIR, os.path.basename(img_file)) img = Image.fromarray(instance['image'], 'RGB') img.save(output_file) print("\nDone!")
def __init__(self, tl_score_threshold, norm_wrt=(SILICON_EYE.height, SILICON_EYE.width), labels_file='zauron_label_map.json'): self._labels = load_labels(labels_file) self._n_instances = 0 self._objstats = [] self._norm_wrt = norm_wrt self._tl_score_thresh = tl_score_threshold self._keep_score_label_map = { 'None': 'All', 'False': 'Difficult', 'True': 'Approved' }
def plot_from_corestats(corestats, files, comparison_plot=False): """ Iterates through all corestats and generates filenames and plots Uploads to google sheets if specified :param corestats: :param files: :param comparison_plot: :return: """ if UPLOAD_TO_SHEETS: sheets = GoogleSheetsInterface() labels = load_labels(LABELS) AP, mAP = compute_scores_from_corestats(corestats) if comparison_plot: testnames = [os.path.splitext(os.path.basename(file))[0] for file in files] networks = [] for testname in testnames: network, _ = split_testname(testname) networks.append(network) testname = ' & ' testname = testname.join(networks) plots = plot_performance_metrics(corestats, AP, mAP, labels, testname, relative_bar_chart=True, label_filter=LABEL_FILTER, plot_bars=False) for idx in range(len(corestats)): print_stats(corestats[idx], testnames[idx], AP[idx], mAP[idx]) pdf_file = os.path.join(OUTPUT_DIR, testname) save_plot(plots, pdf_file) else: for idx in range(len(corestats)): testname = os.path.splitext(os.path.basename(files[idx]))[0] network, testset = split_testname(testname) plots = plot_performance_metrics([corestats[idx]], [AP[idx]], [mAP[idx]], labels, network, relative_bar_chart=True, label_filter=LABEL_FILTER, plot_bars=False) print_stats(corestats[idx], testname, AP[idx], mAP[idx]) pdf_file = os.path.join(OUTPUT_DIR, testname) save_plot(plots, pdf_file) if UPLOAD_TO_SHEETS: upload_results(sheets, network, testset, AP[idx], mAP[idx])
def main(): """ Read images, run inference on them and exports them :return: """ detector = Detector(net_id=NET_ARCH, arch_config='zurich_networks', labels_net_arch=LABELS_NET, labels_output=LABELS_OUT, retrieval_thresh=RET_THRESH) filenames = read_filenames(INPUT_DIR, FILTER_KEYWORDS, SENSOR_NAME, None) label_map = load_labels(LABELS_OUT) if not os.path.isdir(OUTPUT_DIR): os.makedirs(OUTPUT_DIR) for count, img_path in enumerate(filenames): print('\r[ %i ] Processing %s' % (count, os.path.basename(img_path)), end='', flush=True) img = np.array(Image.open(img_path)) # Run Object Detection obj_detected = detector.run_inference_on_img(img) classes, scores, boxes = detector.remap_labels(obj_detected.classes, obj_detected.scores, obj_detected.boxes) if len(classes) > 0: classes = np.squeeze(classes, axis=0) scores = np.squeeze(scores, axis=0) boxes = np.squeeze(boxes, axis=0) # Add Visualizations visualize_boxes_and_labels_on_image_array( img, boxes, classes, scores, label_map, use_normalized_coordinates=True, alpha=scores, min_score_thresh=RET_THRESH) if TESTNAME is None: step = int(abs(NET_ARCH) / 10) net = ARCH_DICT[NET_ARCH].upper() sensor = SENSOR_NAME time = 'DAY' if 'day' in img_path else 'NIGHT' if 'night' in img_path else 'N/A' overlay_string = 'step:%s network:%s sensor:%s time:%s' % ( step, net, sensor, time) else: overlay_string = TESTNAME img = add_text_overlay(img, overlay_string, overlay=False, fontsize=14) if VERBOSE: cv2.imshow('Actual Frame', cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) cv2.waitKey(1) # Save image as png output_file = os.path.join(OUTPUT_DIR, '%05d.png' % count) img = Image.fromarray(img, 'RGB') img.save(output_file)
def run_evaluation(flags): """ Evaluates datasets for objects detected and uploads them to Google Sheet :param flags: :return: """ stats = TLStatistician(tl_score_threshold=0) labels = load_labels(flags.labels_output) sheets = GoogleSheetsInterface() with tf.Session() as sess: # "Dataset" filenames_placeholder = tf.placeholder(tf.string, shape=[None]) testfiles = [os.path.join(flags.input_dir, flags.filename)] dataset = tf.data.TFRecordDataset(filenames_placeholder) # Parsing input function takes care of reading and formatting the TFrecords dataset = dataset.map(_input_parser) dataset = dataset.repeat(1) dataset = dataset.batch(flags.batch_size) # Initialize input readers iterator = dataset.make_initializable_iterator() next_batch = iterator.get_next() sess.run(iterator.initializer, feed_dict={filenames_placeholder: testfiles}) batch_count = 0 while True: try: # Read in next batch print('\r[ %i ] Analysing batches...' % batch_count, end='', flush=True) batch_in = sess.run(next_batch) img_in = batch_in['frame'][0, :] gt_labels = batch_in['gt_labels'][0, :] gt_boxes = batch_in['gt_boxes'][0, :] difficult_flag = batch_in['difficult_flag'][0, :] if len(difficult_flag) == 0 and len(gt_labels) > 0: difficult_flag = [0] * len(gt_labels) # Add objects to stats for idx, class_id in enumerate(gt_labels): stats.append_obj_stats( label=class_id, ymin=gt_boxes[idx][0], xmin=gt_boxes[idx][1], h=gt_boxes[idx][2] - gt_boxes[idx][0], w=gt_boxes[idx][3] - gt_boxes[idx][1], tl_score=0, tl_difficult=abs(difficult_flag[idx] - 1)) # Show example if verbose == True if flags.verbose: img = np.copy(img_in) visualize_boxes_and_labels_on_image_array( img, gt_boxes, gt_labels, None, labels=labels, use_normalized_coordinates=True, difficult=difficult_flag) plt.imshow(img) plt.show() batch_count += 1 stats.n_instances += 1 except tf.errors.OutOfRangeError: break # Create plots to be stored in output folder output_name = os.path.splitext(flags.filename)[0] if flags.make_plots: if not os.path.isdir(flags.output_dir): os.makedirs(flags.output_dir) stats.make_plots(save_plots=True, output_dir=flags.output_dir, filename=output_name, show_plots=flags.verbose, labels_dict=labels) # Prepare data for upload to google sheets result page values = [] for idx in range(len(labels)): number = len(stats.get_tlscores(label_filt=idx + 1, tl_keep_filt=1)) diff = len(stats.get_tlscores(label_filt=idx + 1, tl_keep_filt=0)) values.append('%d (%d)' % (number, diff)) values.append(len(stats.get_tlscores())) sheets.upload_data(flags.google_sheet, 'B', 'I', output_name, values) return
def __init__(self): self._labels = load_labels('zauron_label_map.json') # Only initialize in the instance that really needs it self._img_blender = None
def create_tfrecords_fromhandlabels(flags): """ Recursively creates an tfrecord for each image that has been labeled Can be filtered by tags set in the flags :param flags: :return: """ if flags.learning_filter: # Initialize filter _learning_filter = LearningFilter( score_threshold=flags.lf_score_thresh, min_img_perimeter=flags.min_obj_size, logstats=True, mode=flags.lf_mode, verbose=False) lf_base_images = [ os.path.join(flags.image_src, f) for f in os.listdir(flags.image_src) if f.endswith(".png") and flags.filter_lf_base_keyword in f ] lf_base_images.sort() images = [ os.path.join(flags.image_src, f) for f in os.listdir(flags.image_src) if f.endswith(".png") and flags.filter_keyword in f ] labels_xml = [ os.path.join(flags.image_src_labels, f) for f in os.listdir(flags.image_src_labels) if f.endswith(".xml") ] images.sort() labels_xml.sort() assert len(images) == len(labels_xml), \ "Uneven amounts of labels (%s) and images (%s) found!" % (len(labels_xml), len(images)) print('Found %i labeled objects' % len(labels_xml)) encoder = EncoderTFrecGoogleApi() # Check if object satisfies filter features # if flags.filter_keyword is not None: # labels_xml = _filter_input(labels_xml, flags.filter_keyword) classes = load_labels(flags.labels_map) class_names = { classes[i]['name']: i for i in list(range(1, len(classes) + 1)) } print('Found %i objects satisfying condition: %s' % (len(labels_xml), flags.data_filter)) if flags.output_file is not None: output = os.path.join(flags.output_dir, flags.output_file) else: file = '_'.join(flags.data_filter) extension = '_%s.tfrecord' % flags.image_type output = os.path.join(flags.output_dir, file + extension) # Parse labels and create tfrecord example try: with tf.python_io.TFRecordWriter(output) as writer: # Loop through objects and create tfrecords for idx, (img_file, xml_file) in enumerate(zip(images, labels_xml)): xml_tree = ET.parse(xml_file).getroot() xml_data = _recursive_parse_xml_to_dict(xml_tree) instance = dict_to_tf_instance(xml_data['annotation'], img_file, class_names) # Apply learning filter if defined if flags.learning_filter: img_main = np.array(Image.open(lf_base_images[idx])) classes_filtered, boxes_filtered = _learning_filter.apply( img_main, instance['image'], instance['labels'], instance['boxes']) instance['labels'] = classes_filtered instance['boxes'] = boxes_filtered example = encoder.encode(instance, flags.difficult_flag) writer.write(example.SerializeToString()) print('\r[ %i / %i ] %s' % (idx + 1, len(labels_xml), os.path.basename(img_file)), end='', flush=True) except IOError as e: e.args += ('Failed attempting to serialize tfRecord file: %s' % img_file) return