SamMorgan

Adding more yolov4-tflite files

20e841b over 2 years ago

No virus

27.9 kB

	import glob
	import json
	import os
	import shutil
	import operator
	import sys
	import argparse
	from absl import app, flags, logging
	from absl.flags import FLAGS

	MINOVERLAP = 0.5 # default value (defined in the PASCAL VOC2012 challenge)

	parser = argparse.ArgumentParser()
	parser.add_argument('-na', '--no-animation',default=True, help="no animation is shown.", action="store_true")
	parser.add_argument('-np', '--no-plot', help="no plot is shown.", action="store_true")
	parser.add_argument('-q', '--quiet', help="minimalistic console output.", action="store_true")
	# argparse receiving list of classes to be ignored
	parser.add_argument('-i', '--ignore', nargs='+', type=str, help="ignore a list of classes.")
	parser.add_argument('-o', '--output', default="results", type=str, help="output path name")
	# argparse receiving list of classes with specific IoU
	parser.add_argument('--set-class-iou', nargs='+', type=str, help="set IoU for a specific class.")
	args = parser.parse_args()

	# if there are no classes to ignore then replace None by empty list
	if args.ignore is None:
	args.ignore = []

	specific_iou_flagged = False
	if args.set_class_iou is not None:
	specific_iou_flagged = True

	# if there are no images then no animation can be shown
	img_path = 'images'
	if os.path.exists(img_path):
	for dirpath, dirnames, files in os.walk(img_path):
	if not files:
	# no image files found
	args.no_animation = True
	else:
	args.no_animation = True

	# try to import OpenCV if the user didn't choose the option --no-animation
	show_animation = False
	if not args.no_animation:
	try:
	import cv2
	show_animation = True
	except ImportError:
	print("\"opencv-python\" not found, please install to visualize the results.")
	args.no_animation = True

	# try to import Matplotlib if the user didn't choose the option --no-plot
	draw_plot = False
	if not args.no_plot:
	try:
	import matplotlib.pyplot as plt
	draw_plot = True
	except ImportError:
	print("\"matplotlib\" not found, please install it to get the resulting plots.")
	args.no_plot = True

	"""
	throw error and exit
	"""
	def error(msg):
	print(msg)
	sys.exit(0)

	"""
	check if the number is a float between 0.0 and 1.0
	"""
	def is_float_between_0_and_1(value):
	try:
	val = float(value)
	if val > 0.0 and val < 1.0:
	return True
	else:
	return False
	except ValueError:
	return False

	"""
	Calculate the AP given the recall and precision array
	1st) We compute a version of the measured precision/recall curve with
	precision monotonically decreasing
	2nd) We compute the AP as the area under this curve by numerical integration.
	"""
	def voc_ap(rec, prec):
	"""
	--- Official matlab code VOC2012---
	mrec=[0 ; rec ; 1];
	mpre=[0 ; prec ; 0];
	for i=numel(mpre)-1:-1:1
	mpre(i)=max(mpre(i),mpre(i+1));
	end
	i=find(mrec(2:end)~=mrec(1:end-1))+1;
	ap=sum((mrec(i)-mrec(i-1)).*mpre(i));
	"""
	rec.insert(0, 0.0) # insert 0.0 at begining of list
	rec.append(1.0) # insert 1.0 at end of list
	mrec = rec[:]
	prec.insert(0, 0.0) # insert 0.0 at begining of list
	prec.append(0.0) # insert 0.0 at end of list
	mpre = prec[:]
	"""
	This part makes the precision monotonically decreasing
	(goes from the end to the beginning)
	matlab: for i=numel(mpre)-1:-1:1
	mpre(i)=max(mpre(i),mpre(i+1));
	"""
	# matlab indexes start in 1 but python in 0, so I have to do:
	# range(start=(len(mpre) - 2), end=0, step=-1)
	# also the python function range excludes the end, resulting in:
	# range(start=(len(mpre) - 2), end=-1, step=-1)
	for i in range(len(mpre)-2, -1, -1):
	mpre[i] = max(mpre[i], mpre[i+1])
	"""
	This part creates a list of indexes where the recall changes
	matlab: i=find(mrec(2:end)~=mrec(1:end-1))+1;
	"""
	i_list = []
	for i in range(1, len(mrec)):
	if mrec[i] != mrec[i-1]:
	i_list.append(i) # if it was matlab would be i + 1
	"""
	The Average Precision (AP) is the area under the curve
	(numerical integration)
	matlab: ap=sum((mrec(i)-mrec(i-1)).*mpre(i));
	"""
	ap = 0.0
	for i in i_list:
	ap += ((mrec[i]-mrec[i-1])*mpre[i])
	return ap, mrec, mpre


	"""
	Convert the lines of a file to a list
	"""
	def file_lines_to_list(path):
	# open txt file lines to a list
	with open(path) as f:
	content = f.readlines()
	# remove whitespace characters like `\n` at the end of each line
	content = [x.strip() for x in content]
	return content

	"""
	Draws text in image
	"""
	def draw_text_in_image(img, text, pos, color, line_width):
	font = cv2.FONT_HERSHEY_PLAIN
	fontScale = 1
	lineType = 1
	bottomLeftCornerOfText = pos
	cv2.putText(img, text,
	bottomLeftCornerOfText,
	font,
	fontScale,
	color,
	lineType)
	text_width, _ = cv2.getTextSize(text, font, fontScale, lineType)[0]
	return img, (line_width + text_width)

	"""
	Plot - adjust axes
	"""
	def adjust_axes(r, t, fig, axes):
	# get text width for re-scaling
	bb = t.get_window_extent(renderer=r)
	text_width_inches = bb.width / fig.dpi
	# get axis width in inches
	current_fig_width = fig.get_figwidth()
	new_fig_width = current_fig_width + text_width_inches
	propotion = new_fig_width / current_fig_width
	# get axis limit
	x_lim = axes.get_xlim()
	axes.set_xlim([x_lim[0], x_lim[1]*propotion])

	"""
	Draw plot using Matplotlib
	"""
	def draw_plot_func(dictionary, n_classes, window_title, plot_title, x_label, output_path, to_show, plot_color, true_p_bar):
	# sort the dictionary by decreasing value, into a list of tuples
	sorted_dic_by_value = sorted(dictionary.items(), key=operator.itemgetter(1))
	# unpacking the list of tuples into two lists
	sorted_keys, sorted_values = zip(*sorted_dic_by_value)
	#
	if true_p_bar != "":
	"""
	Special case to draw in (green=true predictions) & (red=false predictions)
	"""
	fp_sorted = []
	tp_sorted = []
	for key in sorted_keys:
	fp_sorted.append(dictionary[key] - true_p_bar[key])
	tp_sorted.append(true_p_bar[key])
	plt.barh(range(n_classes), fp_sorted, align='center', color='crimson', label='False Predictions')
	plt.barh(range(n_classes), tp_sorted, align='center', color='forestgreen', label='True Predictions', left=fp_sorted)
	# add legend
	plt.legend(loc='lower right')
	"""
	Write number on side of bar
	"""
	fig = plt.gcf() # gcf - get current figure
	axes = plt.gca()
	r = fig.canvas.get_renderer()
	for i, val in enumerate(sorted_values):
	fp_val = fp_sorted[i]
	tp_val = tp_sorted[i]
	fp_str_val = " " + str(fp_val)
	tp_str_val = fp_str_val + " " + str(tp_val)
	# trick to paint multicolor with offset:
	# first paint everything and then repaint the first number
	t = plt.text(val, i, tp_str_val, color='forestgreen', va='center', fontweight='bold')
	plt.text(val, i, fp_str_val, color='crimson', va='center', fontweight='bold')
	if i == (len(sorted_values)-1): # largest bar
	adjust_axes(r, t, fig, axes)
	else:
	plt.barh(range(n_classes), sorted_values, color=plot_color)
	"""
	Write number on side of bar
	"""
	fig = plt.gcf() # gcf - get current figure
	axes = plt.gca()
	r = fig.canvas.get_renderer()
	for i, val in enumerate(sorted_values):
	str_val = " " + str(val) # add a space before
	if val < 1.0:
	str_val = " {0:.2f}".format(val)
	t = plt.text(val, i, str_val, color=plot_color, va='center', fontweight='bold')
	# re-set axes to show number inside the figure
	if i == (len(sorted_values)-1): # largest bar
	adjust_axes(r, t, fig, axes)
	# set window title
	fig.canvas.set_window_title(window_title)
	# write classes in y axis
	tick_font_size = 12
	plt.yticks(range(n_classes), sorted_keys, fontsize=tick_font_size)
	"""
	Re-scale height accordingly
	"""
	init_height = fig.get_figheight()
	# comput the matrix height in points and inches
	dpi = fig.dpi
	height_pt = n_classes * (tick_font_size * 1.4) # 1.4 (some spacing)
	height_in = height_pt / dpi
	# compute the required figure height
	top_margin = 0.15 # in percentage of the figure height
	bottom_margin = 0.05 # in percentage of the figure height
	figure_height = height_in / (1 - top_margin - bottom_margin)
	# set new height
	if figure_height > init_height:
	fig.set_figheight(figure_height)

	# set plot title
	plt.title(plot_title, fontsize=14)
	# set axis titles
	# plt.xlabel('classes')
	plt.xlabel(x_label, fontsize='large')
	# adjust size of window
	fig.tight_layout()
	# save the plot
	fig.savefig(output_path)
	# show image
	if to_show:
	plt.show()
	# close the plot
	plt.close()

	"""
	Create a "tmp_files/" and "results/" directory
	"""
	tmp_files_path = "tmp_files"
	if not os.path.exists(tmp_files_path): # if it doesn't exist already
	os.makedirs(tmp_files_path)
	results_files_path = args.output
	if os.path.exists(results_files_path): # if it exist already
	# reset the results directory
	shutil.rmtree(results_files_path)

	os.makedirs(results_files_path)
	if draw_plot:
	os.makedirs(results_files_path + "/classes")
	if show_animation:
	os.makedirs(results_files_path + "/images")
	os.makedirs(results_files_path + "/images/single_predictions")

	"""
	Ground-Truth
	Load each of the ground-truth files into a temporary ".json" file.
	Create a list of all the class names present in the ground-truth (gt_classes).
	"""
	# get a list with the ground-truth files
	ground_truth_files_list = glob.glob('ground-truth/*.txt')
	if len(ground_truth_files_list) == 0:
	error("Error: No ground-truth files found!")
	ground_truth_files_list.sort()
	# dictionary with counter per class
	gt_counter_per_class = {}

	for txt_file in ground_truth_files_list:
	#print(txt_file)
	file_id = txt_file.split(".txt",1)[0]
	file_id = os.path.basename(os.path.normpath(file_id))
	# check if there is a correspondent predicted objects file
	if not os.path.exists('predicted/' + file_id + ".txt"):
	error_msg = "Error. File not found: predicted/" + file_id + ".txt\n"
	error_msg += "(You can avoid this error message by running extra/intersect-gt-and-pred.py)"
	error(error_msg)
	lines_list = file_lines_to_list(txt_file)
	# create ground-truth dictionary
	bounding_boxes = []
	is_difficult = False
	for line in lines_list:
	try:
	if "difficult" in line:
	class_name, left, top, right, bottom, _difficult = line.split()
	is_difficult = True
	else:
	class_name, left, top, right, bottom = line.split()
	except ValueError:
	error_msg = "Error: File " + txt_file + " in the wrong format.\n"
	error_msg += " Expected: <class_name> <left> <top> <right> <bottom> ['difficult']\n"
	error_msg += " Received: " + line
	error_msg += "\n\nIf you have a <class_name> with spaces between words you should remove them\n"
	error_msg += "by running the script \"remove_space.py\" or \"rename_class.py\" in the \"extra/\" folder."
	error(error_msg)
	# check if class is in the ignore list, if yes skip
	if class_name in args.ignore:
	continue
	bbox = left + " " + top + " " + right + " " +bottom
	if is_difficult:
	bounding_boxes.append({"class_name":class_name, "bbox":bbox, "used":False, "difficult":True})
	is_difficult = False
	else:
	bounding_boxes.append({"class_name":class_name, "bbox":bbox, "used":False})
	# count that object
	if class_name in gt_counter_per_class:
	gt_counter_per_class[class_name] += 1
	else:
	# if class didn't exist yet
	gt_counter_per_class[class_name] = 1
	# dump bounding_boxes into a ".json" file
	with open(tmp_files_path + "/" + file_id + "_ground_truth.json", 'w') as outfile:
	json.dump(bounding_boxes, outfile)

	gt_classes = list(gt_counter_per_class.keys())
	# let's sort the classes alphabetically
	gt_classes = sorted(gt_classes)
	n_classes = len(gt_classes)
	#print(gt_classes)
	#print(gt_counter_per_class)

	"""
	Check format of the flag --set-class-iou (if used)
	e.g. check if class exists
	"""
	if specific_iou_flagged:
	n_args = len(args.set_class_iou)
	error_msg = \
	'\n --set-class-iou [class_1] [IoU_1] [class_2] [IoU_2] [...]'
	if n_args % 2 != 0:
	error('Error, missing arguments. Flag usage:' + error_msg)
	# [class_1] [IoU_1] [class_2] [IoU_2]
	# specific_iou_classes = ['class_1', 'class_2']
	specific_iou_classes = args.set_class_iou[::2] # even
	# iou_list = ['IoU_1', 'IoU_2']
	iou_list = args.set_class_iou[1::2] # odd
	if len(specific_iou_classes) != len(iou_list):
	error('Error, missing arguments. Flag usage:' + error_msg)
	for tmp_class in specific_iou_classes:
	if tmp_class not in gt_classes:
	error('Error, unknown class \"' + tmp_class + '\". Flag usage:' + error_msg)
	for num in iou_list:
	if not is_float_between_0_and_1(num):
	error('Error, IoU must be between 0.0 and 1.0. Flag usage:' + error_msg)

	"""
	Predicted
	Load each of the predicted files into a temporary ".json" file.
	"""
	# get a list with the predicted files
	predicted_files_list = glob.glob('predicted/*.txt')
	predicted_files_list.sort()

	for class_index, class_name in enumerate(gt_classes):
	bounding_boxes = []
	for txt_file in predicted_files_list:
	#print(txt_file)
	# the first time it checks if all the corresponding ground-truth files exist
	file_id = txt_file.split(".txt",1)[0]
	file_id = os.path.basename(os.path.normpath(file_id))
	if class_index == 0:
	if not os.path.exists('ground-truth/' + file_id + ".txt"):
	error_msg = "Error. File not found: ground-truth/" + file_id + ".txt\n"
	error_msg += "(You can avoid this error message by running extra/intersect-gt-and-pred.py)"
	error(error_msg)
	lines = file_lines_to_list(txt_file)
	for line in lines:
	try:
	tmp_class_name, confidence, left, top, right, bottom = line.split()
	except ValueError:
	error_msg = "Error: File " + txt_file + " in the wrong format.\n"
	error_msg += " Expected: <class_name> <confidence> <left> <top> <right> <bottom>\n"
	error_msg += " Received: " + line
	error(error_msg)
	if tmp_class_name == class_name:
	#print("match")
	bbox = left + " " + top + " " + right + " " +bottom
	bounding_boxes.append({"confidence":confidence, "file_id":file_id, "bbox":bbox})
	#print(bounding_boxes)
	# sort predictions by decreasing confidence
	bounding_boxes.sort(key=lambda x:float(x['confidence']), reverse=True)
	with open(tmp_files_path + "/" + class_name + "_predictions.json", 'w') as outfile:
	json.dump(bounding_boxes, outfile)

	"""
	Calculate the AP for each class
	"""
	sum_AP = 0.0
	ap_dictionary = {}
	# open file to store the results
	with open(results_files_path + "/results.txt", 'w') as results_file:
	results_file.write("# AP and precision/recall per class\n")
	count_true_positives = {}
	for class_index, class_name in enumerate(gt_classes):
	count_true_positives[class_name] = 0
	"""
	Load predictions of that class
	"""
	predictions_file = tmp_files_path + "/" + class_name + "_predictions.json"
	predictions_data = json.load(open(predictions_file))

	"""
	Assign predictions to ground truth objects
	"""
	nd = len(predictions_data)
	tp = [0] * nd # creates an array of zeros of size nd
	fp = [0] * nd
	for idx, prediction in enumerate(predictions_data):
	file_id = prediction["file_id"]
	if show_animation:
	# find ground truth image
	ground_truth_img = glob.glob1(img_path, file_id + ".*")
	#tifCounter = len(glob.glob1(myPath,"*.tif"))
	if len(ground_truth_img) == 0:
	error("Error. Image not found with id: " + file_id)
	elif len(ground_truth_img) > 1:
	error("Error. Multiple image with id: " + file_id)
	else: # found image
	#print(img_path + "/" + ground_truth_img[0])
	# Load image
	img = cv2.imread(img_path + "/" + ground_truth_img[0])
	# load image with draws of multiple detections
	img_cumulative_path = results_files_path + "/images/" + ground_truth_img[0]
	if os.path.isfile(img_cumulative_path):
	img_cumulative = cv2.imread(img_cumulative_path)
	else:
	img_cumulative = img.copy()
	# Add bottom border to image
	bottom_border = 60
	BLACK = [0, 0, 0]
	img = cv2.copyMakeBorder(img, 0, bottom_border, 0, 0, cv2.BORDER_CONSTANT, value=BLACK)
	# assign prediction to ground truth object if any
	# open ground-truth with that file_id
	gt_file = tmp_files_path + "/" + file_id + "_ground_truth.json"
	ground_truth_data = json.load(open(gt_file))
	ovmax = -1
	gt_match = -1
	# load prediction bounding-box
	bb = [ float(x) for x in prediction["bbox"].split() ]
	for obj in ground_truth_data:
	# look for a class_name match
	if obj["class_name"] == class_name:
	bbgt = [ float(x) for x in obj["bbox"].split() ]
	bi = [max(bb[0],bbgt[0]), max(bb[1],bbgt[1]), min(bb[2],bbgt[2]), min(bb[3],bbgt[3])]
	iw = bi[2] - bi[0] + 1
	ih = bi[3] - bi[1] + 1
	if iw > 0 and ih > 0:
	# compute overlap (IoU) = area of intersection / area of union
	ua = (bb[2] - bb[0] + 1) * (bb[3] - bb[1] + 1) + (bbgt[2] - bbgt[0]
	+ 1) * (bbgt[3] - bbgt[1] + 1) - iw * ih
	ov = iw * ih / ua
	if ov > ovmax:
	ovmax = ov
	gt_match = obj

	# assign prediction as true positive/don't care/false positive
	if show_animation:
	status = "NO MATCH FOUND!" # status is only used in the animation
	# set minimum overlap
	min_overlap = MINOVERLAP
	if specific_iou_flagged:
	if class_name in specific_iou_classes:
	index = specific_iou_classes.index(class_name)
	min_overlap = float(iou_list[index])
	if ovmax >= min_overlap:
	if "difficult" not in gt_match:
	if not bool(gt_match["used"]):
	# true positive
	tp[idx] = 1
	gt_match["used"] = True
	count_true_positives[class_name] += 1
	# update the ".json" file
	with open(gt_file, 'w') as f:
	f.write(json.dumps(ground_truth_data))
	if show_animation:
	status = "MATCH!"
	else:
	# false positive (multiple detection)
	fp[idx] = 1
	if show_animation:
	status = "REPEATED MATCH!"
	else:
	# false positive
	fp[idx] = 1
	if ovmax > 0:
	status = "INSUFFICIENT OVERLAP"

	"""
	Draw image to show animation
	"""
	if show_animation:
	height, widht = img.shape[:2]
	# colors (OpenCV works with BGR)
	white = (255,255,255)
	light_blue = (255,200,100)
	green = (0,255,0)
	light_red = (30,30,255)
	# 1st line
	margin = 10
	v_pos = int(height - margin - (bottom_border / 2))
	text = "Image: " + ground_truth_img[0] + " "
	img, line_width = draw_text_in_image(img, text, (margin, v_pos), white, 0)
	text = "Class [" + str(class_index) + "/" + str(n_classes) + "]: " + class_name + " "
	img, line_width = draw_text_in_image(img, text, (margin + line_width, v_pos), light_blue, line_width)
	if ovmax != -1:
	color = light_red
	if status == "INSUFFICIENT OVERLAP":
	text = "IoU: {0:.2f}% ".format(ovmax100) + "< {0:.2f}% ".format(min_overlap100)
	else:
	text = "IoU: {0:.2f}% ".format(ovmax100) + ">= {0:.2f}% ".format(min_overlap100)
	color = green
	img, _ = draw_text_in_image(img, text, (margin + line_width, v_pos), color, line_width)
	# 2nd line
	v_pos += int(bottom_border / 2)
	rank_pos = str(idx+1) # rank position (idx starts at 0)
	text = "Prediction #rank: " + rank_pos + " confidence: {0:.2f}% ".format(float(prediction["confidence"])*100)
	img, line_width = draw_text_in_image(img, text, (margin, v_pos), white, 0)
	color = light_red
	if status == "MATCH!":
	color = green
	text = "Result: " + status + " "
	img, line_width = draw_text_in_image(img, text, (margin + line_width, v_pos), color, line_width)

	font = cv2.FONT_HERSHEY_SIMPLEX
	if ovmax > 0: # if there is intersections between the bounding-boxes
	bbgt = [ int(x) for x in gt_match["bbox"].split() ]
	cv2.rectangle(img,(bbgt[0],bbgt[1]),(bbgt[2],bbgt[3]),light_blue,2)
	cv2.rectangle(img_cumulative,(bbgt[0],bbgt[1]),(bbgt[2],bbgt[3]),light_blue,2)
	cv2.putText(img_cumulative, class_name, (bbgt[0],bbgt[1] - 5), font, 0.6, light_blue, 1, cv2.LINE_AA)
	bb = [int(i) for i in bb]
	cv2.rectangle(img,(bb[0],bb[1]),(bb[2],bb[3]),color,2)
	cv2.rectangle(img_cumulative,(bb[0],bb[1]),(bb[2],bb[3]),color,2)
	cv2.putText(img_cumulative, class_name, (bb[0],bb[1] - 5), font, 0.6, color, 1, cv2.LINE_AA)
	# show image
	cv2.imshow("Animation", img)
	cv2.waitKey(20) # show for 20 ms
	# save image to results
	output_img_path = results_files_path + "/images/single_predictions/" + class_name + "_prediction" + str(idx) + ".jpg"
	cv2.imwrite(output_img_path, img)
	# save the image with all the objects drawn to it
	cv2.imwrite(img_cumulative_path, img_cumulative)

	#print(tp)
	# compute precision/recall
	cumsum = 0
	for idx, val in enumerate(fp):
	fp[idx] += cumsum
	cumsum += val
	cumsum = 0
	for idx, val in enumerate(tp):
	tp[idx] += cumsum
	cumsum += val
	#print(tp)
	rec = tp[:]
	for idx, val in enumerate(tp):
	rec[idx] = float(tp[idx]) / gt_counter_per_class[class_name]
	#print(rec)
	prec = tp[:]
	for idx, val in enumerate(tp):
	prec[idx] = float(tp[idx]) / (fp[idx] + tp[idx])
	#print(prec)

	ap, mrec, mprec = voc_ap(rec, prec)
	sum_AP += ap
	text = "{0:.2f}%".format(ap100) + " = " + class_name + " AP " #class_name + " AP = {0:.2f}%".format(ap100)
	"""
	Write to results.txt
	"""
	rounded_prec = [ '%.2f' % elem for elem in prec ]
	rounded_rec = [ '%.2f' % elem for elem in rec ]
	results_file.write(text + "\n Precision: " + str(rounded_prec) + "\n Recall :" + str(rounded_rec) + "\n\n")
	if not args.quiet:
	print(text)
	ap_dictionary[class_name] = ap

	"""
	Draw plot
	"""
	if draw_plot:
	plt.plot(rec, prec, '-o')
	# add a new penultimate point to the list (mrec[-2], 0.0)
	# since the last line segment (and respective area) do not affect the AP value
	area_under_curve_x = mrec[:-1] + [mrec[-2]] + [mrec[-1]]
	area_under_curve_y = mprec[:-1] + [0.0] + [mprec[-1]]
	plt.fill_between(area_under_curve_x, 0, area_under_curve_y, alpha=0.2, edgecolor='r')
	# set window title
	fig = plt.gcf() # gcf - get current figure
	fig.canvas.set_window_title('AP ' + class_name)
	# set plot title
	plt.title('class: ' + text)
	#plt.suptitle('This is a somewhat long figure title', fontsize=16)
	# set axis titles
	plt.xlabel('Recall')
	plt.ylabel('Precision')
	# optional - set axes
	axes = plt.gca() # gca - get current axes
	axes.set_xlim([0.0,1.0])
	axes.set_ylim([0.0,1.05]) # .05 to give some extra space
	# Alternative option -> wait for button to be pressed
	#while not plt.waitforbuttonpress(): pass # wait for key display
	# Alternative option -> normal display
	#plt.show()
	# save the plot
	fig.savefig(results_files_path + "/classes/" + class_name + ".png")
	plt.cla() # clear axes for next plot

	if show_animation:
	cv2.destroyAllWindows()

	results_file.write("\n# mAP of all classes\n")
	mAP = sum_AP / n_classes
	text = "mAP = {0:.2f}%".format(mAP*100)
	results_file.write(text + "\n")
	print(text)

	# remove the tmp_files directory
	shutil.rmtree(tmp_files_path)

	"""
	Count total of Predictions
	"""
	# iterate through all the files
	pred_counter_per_class = {}
	#all_classes_predicted_files = set([])
	for txt_file in predicted_files_list:
	# get lines to list
	lines_list = file_lines_to_list(txt_file)
	for line in lines_list:
	class_name = line.split()[0]
	# check if class is in the ignore list, if yes skip
	if class_name in args.ignore:
	continue
	# count that object
	if class_name in pred_counter_per_class:
	pred_counter_per_class[class_name] += 1
	else:
	# if class didn't exist yet
	pred_counter_per_class[class_name] = 1
	#print(pred_counter_per_class)
	pred_classes = list(pred_counter_per_class.keys())


	"""
	Plot the total number of occurences of each class in the ground-truth
	"""
	if draw_plot:
	window_title = "Ground-Truth Info"
	plot_title = "Ground-Truth\n"
	plot_title += "(" + str(len(ground_truth_files_list)) + " files and " + str(n_classes) + " classes)"
	x_label = "Number of objects per class"
	output_path = results_files_path + "/Ground-Truth Info.png"
	to_show = False
	plot_color = 'forestgreen'
	draw_plot_func(
	gt_counter_per_class,
	n_classes,
	window_title,
	plot_title,
	x_label,
	output_path,
	to_show,
	plot_color,
	'',
	)

	"""
	Write number of ground-truth objects per class to results.txt
	"""
	with open(results_files_path + "/results.txt", 'a') as results_file:
	results_file.write("\n# Number of ground-truth objects per class\n")
	for class_name in sorted(gt_counter_per_class):
	results_file.write(class_name + ": " + str(gt_counter_per_class[class_name]) + "\n")

	"""
	Finish counting true positives
	"""
	for class_name in pred_classes:
	# if class exists in predictions but not in ground-truth then there are no true positives in that class
	if class_name not in gt_classes:
	count_true_positives[class_name] = 0
	#print(count_true_positives)

	"""
	Plot the total number of occurences of each class in the "predicted" folder
	"""
	if draw_plot:
	window_title = "Predicted Objects Info"
	# Plot title
	plot_title = "Predicted Objects\n"
	plot_title += "(" + str(len(predicted_files_list)) + " files and "
	count_non_zero_values_in_dictionary = sum(int(x) > 0 for x in list(pred_counter_per_class.values()))
	plot_title += str(count_non_zero_values_in_dictionary) + " detected classes)"
	# end Plot title
	x_label = "Number of objects per class"
	output_path = results_files_path + "/Predicted Objects Info.png"
	to_show = False
	plot_color = 'forestgreen'
	true_p_bar = count_true_positives
	draw_plot_func(
	pred_counter_per_class,
	len(pred_counter_per_class),
	window_title,
	plot_title,
	x_label,
	output_path,
	to_show,
	plot_color,
	true_p_bar
	)

	"""
	Write number of predicted objects per class to results.txt
	"""
	with open(results_files_path + "/results", 'a') as results_file:
	results_file.write("\n# Number of predicted objects per class\n")
	for class_name in sorted(pred_classes):
	n_pred = pred_counter_per_class[class_name]
	text = class_name + ": " + str(n_pred)
	text += " (tp:" + str(count_true_positives[class_name]) + ""
	text += ", fp:" + str(n_pred - count_true_positives[class_name]) + ")\n"
	results_file.write(text)

	"""
	Draw mAP plot (Show AP's of all classes in decreasing order)
	"""
	if draw_plot:
	window_title = "mAP"
	plot_title = "mAP = {0:.2f}%".format(mAP*100)
	x_label = "Average Precision"
	output_path = results_files_path + "/mAP.png"
	to_show = True
	plot_color = 'royalblue'
	draw_plot_func(
	ap_dictionary,
	n_classes,
	window_title,
	plot_title,
	x_label,
	output_path,
	to_show,
	plot_color,
	""
	)