Python如何将LabelMe生成的JSON格式转换成YOLOv8支持的TXT格式

import os
import json
import argparse
import colorama
import random
import shutil
def parse_args():
	parser = argparse.argumentparser(description="json(labelme) to txt(yolov8)")
	parser.add_argument("--dir", required=true, type=str, help="images, json files, and generated txt files, all in the same directory")
	parser.add_argument("--labels", required=true, type=str, help="txt file that hold indexes and labels, one label per line, for example: face 0")
	parser.add_argument("--val_size", default=0.2, type=float, help="the proportion of the validation set to the overall dataset:[0., 0.5]")
	parser.add_argument("--name", required=true, type=str, help="the name of the dataset")
	args = parser.parse_args()
	return args
def get_labels_index(name):
	labels = {} # key,value
	with open(name, "r") as file:
		for line in file:
			# print("line:", line)
			key_value = []
			for v in line.split(" "):
				# print("v:", v)
				key_value.append(v.replace("\n", "")) # remove line breaks(\n) at the end of the line
			if len(key_value) != 2:
				print(colorama.fore.red + "error: each line should have only two values(key value):", len(key_value))
				continue
			labels[key_value[0]] = key_value[1]
	with open(name, "r") as file:
		line_num = len(file.readlines())
	if line_num != len(labels):
		print(colorama.fore.red + "error: there may be duplicate lables:", line_num, len(labels))
	return labels
def get_json_files(dir):
	jsons = []
	for x in os.listdir(dir):
		if x.endswith(".json"):
			jsons.append(x)
	return jsons
def parse_json(name):
	with open(name, "r") as file:
		data = json.load(file)
	width = data["imagewidth"]
	height = data["imageheight"]
	# print(f"width: {width}; height: {height}")
	objects=[]
	for shape in data["shapes"]:
		if shape["shape_type"] != "rectangle":
			print(colorama.fore.yellow + "warning: only the rectangle type is supported:", shape["shape_type"])
			continue
		object = []
		object.append(shape["label"])
		object.append(shape["points"])
		objects.append(object)
	return width, height, objects
def get_box_width_height(box):
	dist = lambda val: max(val) - min(val)
	x = [pt[0] for pt in box]
	y = [pt[1] for pt in box]
	return min(x), min(y), dist(x), dist(y)
def bounding_box_normalization(width, height, objects, labels):
	boxes = []
	for object in objects:
		box = [] # class x_center y_center width height
		box.append(labels[object[0]])
		# print("point:", object[1])
		x_min, y_min, box_w, box_h = get_box_width_height(object[1])
		box.append(round((float(x_min + box_w / 2.0) / width), 6))
		box.append(round((float(y_min + box_h / 2.0) / height), 6))
		box.append(round(float(box_w / width), 6))
		box.append(round(float(box_h / height), 6))
		boxes.append(box)
	return boxes	
def write_to_txt(dir, json, width, height, objects, labels):
	boxes = bounding_box_normalization(width, height, objects, labels)
	# print("boxes:", boxes)
	name = json[:-len(".json")] + ".txt"
	# print("name:", name)
	with open(dir + "/" + name, "w") as file:
		for item in boxes:
			# print("item:", item)
			if len(item) != 5:
				print(colorama.fore.red + "error: the length must be 5:", len(item))
				continue
			string = item[0] + " " + str(item[1]) + " " + str(item[2]) + " " + str(item[3]) + " " + str(item[4]) + "\r"
			file.write(string)
def json_to_txt(dir, jsons, labels):
	for json in jsons:
		name = dir + "/" + json
		# print("name:", name)
		width, height, objects = parse_json(name)
		# print(f"width: {width}; height: {height}; objects: {objects}")
		write_to_txt(dir, json, width, height, objects, labels)
def is_in_range(value, a, b):
	return a <= value <= b
def get_random_sequence(length, val_size):
	numbers = list(range(0, length))
	val_sequence = random.sample(numbers, int(length*val_size))
	# print("val_sequence:", val_sequence)
	train_sequence = [x for x in numbers if x not in val_sequence]
	# print("train_sequence:", train_sequence)
	return train_sequence, val_sequence
def get_files_number(dir):
	count = 0
	for file in os.listdir(dir):
		if os.path.isfile(os.path.join(dir, file)):
			count += 1
	return count
def split_train_val(dir, jsons, name, val_size):
	if is_in_range(val_size, 0., 0.5) is false:
		print(colorama.fore.red + "error: the interval for val_size should be:[0., 0.5]:", val_size)
		raise
	dst_dir_images_train = "datasets/" + name + "/images/train"
	dst_dir_images_val = "datasets/" + name + "/images/val"
	dst_dir_labels_train = "datasets/" + name + "/labels/train"
	dst_dir_labels_val = "datasets/" + name + "/labels/val"
	try:
		os.makedirs(dst_dir_images_train) #, exist_ok=true
		os.makedirs(dst_dir_images_val)
		os.makedirs(dst_dir_labels_train)
		os.makedirs(dst_dir_labels_val)
	except oserror as e:
		print(colorama.fore.red + "error: cannot create directory:", e.strerror)
		raise
	# supported image formats
	img_formats = (".bmp", ".jpeg", ".jpg", ".png", ".webp")
	# print("jsons:", jsons)
	train_sequence, val_sequence = get_random_sequence(len(jsons), val_size)
	for index in train_sequence:
		for format in img_formats:
			file = dir + "/" + jsons[index][:-len(".json")] + format
			# print("file:", file)
			if os.path.isfile(file):
				shutil.copy(file, dst_dir_images_train)
				break
		file = dir + "/" + jsons[index][:-len(".json")] + ".txt"
		if os.path.isfile(file):
			shutil.copy(file, dst_dir_labels_train)
	for index in val_sequence:
		for format in img_formats:
			file = dir + "/" + jsons[index][:-len(".json")] + format
			if os.path.isfile(file):
				shutil.copy(file, dst_dir_images_val)
				break
		file = dir + "/" + jsons[index][:-len(".json")] + ".txt"
		if os.path.isfile(file):
			shutil.copy(file, dst_dir_labels_val)
	num_images_train = get_files_number(dst_dir_images_train)
	num_images_val = get_files_number(dst_dir_images_val)
	num_labels_train = get_files_number(dst_dir_labels_train)
	num_labels_val = get_files_number(dst_dir_labels_val)
	if  num_images_train + num_images_val != len(jsons) or num_labels_train + num_labels_val != len(jsons):
		print(colorama.fore.red + "error: the number of files is inconsistent:", num_images_train, num_images_val, num_labels_train, num_labels_val, len(jsons))
		raise
def generate_yaml_file(labels, name):
	path = os.path.join("datasets", name, name+".yaml")
	# print("path:", path)
	with open(path, "w") as file:
		file.write("path: ../datasets/%s # dataset root dir\n" % name)
		file.write("train: images/train # train images (relative to 'path')\n")
		file.write("val: images/val  # val images (relative to 'path')\n")
		file.write("test: # test images (optional)\n\n")
		file.write("# classes\n")
		file.write("names:\n")
		for key, value in labels.items():
			# print(f"key: {key}; value: {value}")
			file.write("  %d: %s\n" % (int(value), key))
if __name__ == "__main__":
	colorama.init()
	args = parse_args()
	# 1. parse json file and write it to a txt file
	labels = get_labels_index(args.labels)
	# print("labels:", labels)
	jsons = get_json_files(args.dir)
	# print("jsons:", jsons)
	json_to_txt(args.dir, jsons, labels)
	# 2. split the dataset
	split_train_val(args.dir, jsons, args.name, args.val_size)
	# 3. generate a yaml file
	generate_yaml_file(labels, args.name)
	print(colorama.fore.green + "====== execution completed ======")

path: ../datasets/fake # dataset root dir
train: images/train # train images (relative to 'path')
val: images/val  # val images (relative to 'path')
test: # test images (optional)
# classes
names:
  0: face
  1: hand
  2: eye
  3: mouth
  4: horse
  5: tree
  6: bridge
  7: house

import argparse
import colorama
from ultralytics import yolo
def parse_args():
	parser = argparse.argumentparser(description="yolov8 object detect")
	parser.add_argument("--yaml", required=true, type=str, help="yaml file")
	parser.add_argument("--epochs", required=true, type=int, help="number of training")
	args = parser.parse_args()
	return args
def train(yaml, epochs):
	model = yolo("yolov8n.pt") # load a pretrained model
	results = model.train(data=yaml, epochs=epochs, imgsz=640) # train the model
	metrics = model.val() # it'll automatically evaluate the data you trained, no arguments needed, dataset and settings remembered
	model.export(format="onnx", dynamic=true) # export the model
if __name__ == "__main__":
	colorama.init()
	args = parse_args()
	train(args.yaml, args.epochs)
	print(colorama.fore.green + "====== execution completed ======")