目标检测数据集xml格式和json的转换标本 COCO数据集的格式
annotation.json文件内容,主要有四个部分需要关注。
{
"categories": [ // 类别组，是一个列表，长度等于类别数。列表的每个元素存放的是数据集的类别，每个类别又是一个字典格式
{
"supercategory": "父类", // 该项表示类别的父类 如果不是特殊情况，通常可以与name相同
"id": 1, // 该项表示类别的序号
"name": "类别1的名字" // 该项表示类别的名字
},
{
"supercategory": "父类",
"id": 2,
"name": "类别2"
}
],
"images"：[ // 图像组，也是一个字典组成的列表。 长度是数据集中的图像数量
{
"file_name": "img_0175153.jpg", // 该项表示图像文件名
"width": 4096, // 图像宽高
"id": 1, // 图像的id序号，这个序号是人为规定的，比如，有n张图，id从1变化到n
"height": 3000
},
{
"file_name": "img_0172993.jpg",
"width": 4096,
"id": 2,
"height": 3000
}
],
"annotations": [ // 标注部分 也是字典构成的列表，它的长度不等于图像文件名，而是 每一个图像的每一个目标 作为列表元素，因此，该列表的长度是 数据集中全部目标的数量
{
"area": 2993, // 该目标区域的面积
"iscrowd": 0, // 是否分块，如果是1，表示一组对象。即该目标被遮挡导致有多个小块
"image_id": 1, // 图片的序号id
"bbox": [ // 该区域的mask外接矩形
2500,
1268,
41,
73
],
"segmentation":[[x1,y1,x2,y2,x3,y3] ], // 掩膜轮廓区域坐标 每相邻xy表示一个点
"category_id": 12, // 目标的类别序号
"id": 1 // 目标的序号id，即在annotation类别中的序号。
},
}
coco的json标签转xml文件
从coco转换到xml格式，只需要从json文件中提取到图像的信息，包括文件名/路径、宽高和标注信息，标注信息只需要类别id和区域的bbox。
具体代码如下，pretty_xml是用于缩进xml文件，进行美化(忘了是在哪个博客看到的了)。write函数用于写入一个xml文件，函数接受一个字典输入info，其key是图像名，value是一个列表，每个元素是图像中的一个目标，以x y w h label的顺序表示，或者x1 y1 x2 y2 label的顺序，shape参数是该图像的hwc，如果没有传入，会试图通过读取文件名来获取该信息。
写入xml的内容都必须是字符串，不能是整数或者浮点数，因此write函数中写入一些数字类型的数据，如坐标、宽高等要转成str。
import time
import cv2
import numpy as np
from PIL import Image
import json
import xml.etree.ElementTree as ET
import random
def pretty_xml(element, indent, newline, level=0): # elemnt为传进来的Elment类，参数indent用于缩进，newline用于换行
if element: # 判断element是否有子元素
if (element.text is None) or element.text.isspace(): # 如果element的text没有内容
element.text = newline + indent * (level + 1)
else:
element.text = newline + indent * (level + 1) + element.text.strip() + newline + indent * (level + 1)
# else: # 此处两行如果把注释去掉，Element的text也会另起一行
# element.text = newline + indent * (level + 1) + element.text.strip() + newline + indent * level
temp = list(element) # 将element转成list
for subelement in temp:
if temp.index(subelement) < (len(temp) - 1): # 如果不是list的最后一个元素，说明下一个行是同级别元素的起始，缩进应一致
subelement.tail = newline + indent * (level + 1)
else: # 如果是list的最后一个元素， 说明下一行是母元素的结束，缩进应该少一个
subelement.tail = newline + indent * level
pretty_xml(subelement, indent, newline, level=level + 1) # 对子元素进行递归操作
# 送入的是dict {图像名字 ：框信息} 框信息是[[x1,y1,w,h,label], [x1,y1,w,h,label],[]]
def write(infos,shape=None):
root = ET.Element('annotation',{"verified":"no"}) # 根节点
folder = ET.SubElement(root, 'folder')
folder.text = '1'
img_name = list(infos.keys())[0].strip() # 图像信息
filename = img_name.split("/")[-1]
file_name = ET.SubElement(root, 'filename')
file_name.text = filename # 文件名这个tag
path = ET.SubElement(root, 'path') # 路径的tag
path.text = img_name
source = ET.SubElement(root, 'source')
database = ET.SubElement(source, 'database')
database.text = "Unknown"
if shape:
h,w,c = shape[0], shape[1],shape[2]
else:
img = cv2.imread(img_name)
h,w,c = img.shape
size = ET.SubElement(root, 'size')
width = ET.SubElement(size, 'width')
width.text = str(w)
height = ET.SubElement(size, 'height')
height.text = str(h)
depth = ET.SubElement(size, 'depth')
depth.text = str(c)
segmented = ET.SubElement(root, 'segmented')
segmented.text = str(0)
for key in infos.keys():
bboxes = infos[key]
for bbox in bboxes:
object_tag = ET.SubElement(root, 'object')
# bbox = ['911', '258', '153', '326', 'class1']
name = ET.SubElement(object_tag, 'name')
name.text = bbox[-1] #框名字
pose = ET.SubElement(object_tag, 'pose')
pose.text = "Unspecified"
trunc = ET.SubElement(object_tag,'truncated')
trunc.text = '0'
diff = ET.SubElement(object_tag,'difficult')
diff.text = '0'
# 下面是写入坐标框
bndbox = ET.SubElement(object_tag,'bndbox')
#left_x: 911 top_y: 258 153 height: 326
bbox[2] = str(int(bbox[2]))
bbox[3] = str(int(bbox[3]))
xmin = ET.SubElement(bndbox,'xmin')
xmin.text = bbox[0]
ymin = ET.SubElement(bndbox,'ymin')
ymin.text = bbox[1]
xmax = ET.SubElement(bndbox,'xmax')
# 如果是 x y w h
# xmax.text = str(int(bbox[0]) + int(bbox[2]) )
# 如果是 x1 y1 x2 y2
xmax.text = str(int(bbox[2]) )
ymax = ET.SubElement(bndbox,'ymax')
# ymax.text = str(int(bbox[1]) + int(bbox[3]) )
ymax.text = str(int(bbox[3]))
pretty_xml(root, ' ', '
') # 执行美化方法
#ET.dump(root)
tree = ET.ElementTree(root)
xml_name = filename.replace("jpg","xml") # 要保存的xml文件名字 和图像文件名相同，仅后缀不同
tree.write(f"F:/xjzh/cocoxml/{xml_name}", encoding="utf-8",xml_declaration=False)
# 打开json标签文件
with open(r'F:xjzh图片annotations.json','r') as f:
data_an = {} # 外围大字典
json_dicts = json.loads(f.read()) #
cate = json_dicts['categories']
cls_name = [0]*len(cate)
for cate_dict in cate:
cls_name[cate_dict['id']] = cate_dict['name'] # 各个类别对应的名字 按顺序放在cls_name中，如id为0的类别名就是cls_name[0]
# 类别 按照id顺序来的
# ['背景', '瓶盖破损', '瓶盖变形', '瓶盖坏边', '瓶盖打旋', '瓶盖断点', '标贴歪斜', '标贴起皱', '标贴气泡', '喷码正常', '喷码异常', '酒液杂质', '瓶身破损', '瓶身气泡']
images_info = json_dicts["images"] # 图像信息
image_nums = len(images_info) # 图像数量
print(image_nums)
file_list = [] # 存放图像基本信息 依次按顺序读入，这样图像image_id是k的图像信息就是file_list[k-1] k从1开始
annot_list = [[] for _ in range(image_nums)] # 存放每个图像对应的框,每个图像的全部目标是一个元素，因此初始化为一个长度和图像数量相同的列表，列表的每个元素是一个空列表，后面用于增加目标框信息
for index in range(image_nums):
# 第 index张图像的信息 包括文件名 宽高
file_name = images_info[index]["file_name"] # id从1变换到2668 索引从0到2667
width = images_info[index]["width"]
height = images_info[index]['height']
# print([file_name,width,height],'-------')
file_list.append([file_name,width,height]) # file_list列表保存
annot = json_dicts["annotations"]
# 根据目标所属的图像id，放到列表对应的位置。从而使一张图片的多个目标聚合在一起
for index in range(len(annot)): # 获取标签信息
# 第index个目标的框可能是x y w h或者x1 y1 x2 y2的形式。按照实际情况修改
annot[index]['bbox'][2] = annot[index]['bbox'][2] + annot[index]['bbox'][0] # 这是x y w h的形式 转成x1 y1 x2 y2的形式。或者不转，和write函数保持一致就可以
annot[index]['bbox'][3] = annot[index]['bbox'][3] + annot[index]['bbox'][1]
# 这个目标的类别id是annot[index]["category_id"] 它的名字是cls[索引] 注意json文件中类别id可能是从1开始，而cls_name的索引是0开始 注意保持对应
annot[index]['bbox'].append(cls_name[ annot[index]["category_id"] ]) # 在框信息后面 加入 label
# print(annot[index]['bbox'],annot[index]['image_id']-1)
# -1是因为该目标对应的图像id是从1开始，因此要放在列表的第 id -1的位置
annot_list[annot[index]['image_id']-1].append(annot[index]['bbox']) # bbox是 x1 y1 w h
# 对每一张图 写入xml文件
for index in range(image_nums):
print(index)
box = annot_list[index]
print(box)
# info的key是文件名 value是坐标列表
write({file_list[index][0]: box},shape=[str(file_list[index][1]),str(file_list[index][0]),'3']) # shape =hwc
xml或者yolo标签转labelme的json格式
目标检测任务，而不是分割任务格式。将xml或者yolo格式的框标注文件转成json格式,格式和labelme标注结果格式相同，而不是coco数据集的json格式。
转换步骤： 从xml文件或者txt文件获取框的坐标，按照labelme的json坐标顺序组织，依次对照json的各个key填充相应内容即可。
labelme标注的json文件内容如下。
labelme 标签的json文件格式
"imagePath":"1.jpg" 图像路径
"fillColor": [255,0,0,128], # 填充颜色，RGB和透明度
"imageData":"/9j/啥啥啥" base64编码
"imageHeight": 768, 图像高度
"flags": {},
"version": "3.16.7",
"imageWidth": 1366, 图像宽度
"lineColor": [0,255,0,128], # 线条颜色
"shapes": [ # shapes是列表，每一个元素是字典。
# 每个字典格式如下
{
"fill_color": null,
"line_color": null,
"shape_type": "polygon", # 多边形 或者 长方形等
"points": [ # 列表点 xy
[
248.8771929824561, 273.2631578947368
],
],
"flags": {},
"label": "person" # 标签
},
import cv2
import xml.etree.ElementTree as ET
import numpy as np
import os
import json
import shutil
import base64
'''
该脚本实现将xml类型标签(或者yolo格式标签)转为json格式标签
需要的数据：原始图像 原始xml标签（原始txt标签）
'''
# 解析数据集，输入单张图片路径，图片路径不能出现中文，因为是cv2读取的。和对应xml文件的路径
# 返回图片 该图所有的目标框[[x1,y1,x2,y2],....] 每个框的类别[label1, label2, label3,.....] 注意是label而不是索引
def parse_img_label(img_path, xml_path): # 绝对路径
img = cv2.imread(img_path)
tree = ET.parse(xml_path)
root = tree.getroot()
objs = root.findall('object')
bboxes = [] # 坐标框
h ,w = img.shape[0], img.shape[1]
#gt_labels = [] # 标签名
for obj in objs: # 遍历所有的目标
label = obj[0].text # <name>这个tag的值，即标签
label = label.strip(' ')
box = [int(obj[4][i].text) for i in range(4)]
box.append(label) # box的元素 x1 y1 x2 y2 类别
bboxes.append(box)
return img, bboxes
# 该函数用于将yolo的标签转回xml需要的标签。。即将归一化后的坐标转为原始的像素坐标
def convert_yolo_xml(box,img): #
x,y,w,h = box[0], box[1], box[2], box[3]
# 求出原始的x1 x2 y1 y2
x2 = (2*x + w)*img.shape[1] /2
x1 = x2 - w*img.shape[1]
y2 = (2*y+h)*img.shape[0] /2
y1 = y2 - h* img.shape[0]
new_box = [x1,y1, x2, y2]
new_box = list(map(int,new_box))
return new_box
# 该函数用于解析yolo格式的数据集，即txt格式的标注 返回图像 边框坐标 真实标签名（不是索引，因此需要预先定义标签）
def parse_img_txt(img_path, txt_path):
name_label = ['class0','class1','class2'] # 需要自己预先定义,它的顺序要和实际yolo格式的标签中0 1 2 3的标签对应 yolo标签的类别是索引 而不是名字
img = cv2.imread(img_path)
f = open(txt_path)
bboxes = []
for line in f.readlines():
line = line.split(" ")
if len(line) == 5:
obj_label = name_label[int(line[0])] # 将类别索引转成其名字
x = float(line[1])
y = float(line[2])
w = float(line[3])
h = float(line[4])
box = convert_yolo_xml([x,y,w,h], img)
box.append(obj_label)
bboxes.append(box)
return img, bboxes
# 制作labelme格式的标签
# 参数说明 img_name： 图像文件名称
# txt_name: 标签文件的绝对路径，注意是绝对路径
# prefix： 图像文件的上级目录名。即形如/home/xjzh/data/ 而img_name是其下的文件名，如00001.jpg
# prefix+img_name即为图像的绝对路径。不该路径能出现中文，否则cv2读取会有问题
#
def get_json(img_name, txt_name, prefix, yolo=False):
# 图片名 标签名 前缀
label_dict = {} # json字典，依次填充它的value
label_dict["imagePath"] = prefix + img_name # 图片路径
label_dict["fillColor"] = [255,0,0,128] # 目标区域的填充颜色 RGBA
label_dict["lineColor"] = [0,255,0,128] # 线条颜色
label_dict["flag"] = {}
label_dict["version"] = "3.16.7" # 版本号，随便
with open(prefix + img_name,"rb") as f:
img_data = f.read()
base64_data = base64.b64encode(img_data)
base64_str = str(base64_data, 'utf-8')
label_dict["imageData"] = base64_str # labelme的json文件存放了图像的base64编码。这样如果图像路径有问题仍然能够打开文件
img, gt_box = parse_img_label(prefix + img_name, txt_name) if not yolo else parse_img_txt(prefix + img_name, txt_name) # 读取真实数据
label_dict["imageHeight"] = img.shape[0] # 高度
label_dict["imageWidth"] = img.shape[1]
shape_list = [] # 存放标注信息的列表，它是 shapes这个键的值。里面是一个列表，每个元素又是一个字典，字典内容是该标注的类型 颜色 坐标点等等
#label_dict["shapes"] = [] # 列表，每个元素是字典。
# box的元素 x1 y1 x2 y2 类别
for box in gt_box:
shape_dict = {} # 表示一个目标的字典
shape_dict["shape_type"] = "rectangle" # 因为xml或yolo格式标签是矩形框标注，因此是rectangle
shape_dict["fill_color"] = None #该类型的填充颜色
shape_dict["line_color"] = None # 线条颜色 可以设置，或者根据标签名自己预先设定labe_color_dict
shape_dict["flags"] = {}
shape_dict["label"] = box[-1] # 标签名
shape_dict["points"] = [[box[0],box[1]], [box[2], box[3]]]
# 通常contours是长度为1的列表，如果有分块，可能就有多个 # [[x1,y1], [x2,y2]...]的列表
shape_list.append(shape_dict)
label_dict["shapes"] = shape_list #
return label_dict
imgs_path = "/home/xjzh/fgd/JPEGImages/" # 图像路径
xmls_path ="/home/xjzh/fgd/Annotations/" # xml文件路径
img_path = os.listdir(imgs_path)
out_json = '/home/xjzh/DATA/JSON_data/' # 保存的json文件路径
for nums, path in enumerate(img_path):
if nums %200==0:
print(f"processed {nums} images")
xml_path = xmls_path + path.replace('jpg','xml') # xml文件的绝对路径
label_dict = get_json(path, xml_path,prefix=imgs_path) #
with open(out_json + path.replace("jpg","json"),'w') as f: # 写入一个json文件
f.write(json.dumps(label_dict, ensure_ascii=False, indent=4, separators=(',', ':')))