devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

目标检测：如何将VOC标注的xml数据转为YOLO标注的txt格式，且生成classes的txt文件_xml格式转yolo格式

作者：我家小花儿 | 2024-03-05 04:59:31

赞

踩

xml格式转yolo格式

1. 前言

目标检测数据的标注分为两种格式：

  • xml 解释性标签，左上角+右下角的坐标
  • txt 记事本文件，类别+x，y中心坐标+w，h的相对值

如下：

xml 文件格式：

txt 文件格式：

本文要实现的目标是将目标检测xml标注格式转为txt相对坐标的标注方式

值得一提的是，xml标注包含了类别名称，往往在<name>下。所以，xml标注的数据有时候没有包含类别的json文件，因为根据xml可以直接绘制边界框。如果想要生成xml对应的类别json字典文件，可以参考：目标检测篇：如何根据xml标注文件生成类别classes的json文件

而对于yolo 标注的txt文件来说，类别仅仅用索引0 1 2表示，这也就是说我们是不知道0 1 2代表什么含义，所以yolo 的数据集往往包含类别的txt文件，方便可视化需要。没有的话，可以参考这个自己生成：关于目标检测任务中，YOLO(txt格式)标注文件的可视化 看文章的Tips

所以本文，将根据VOC标注的xml文件生成YOLO格式的txt文件，且生成yolo需要的类别txt文件

2. 代码实现

简单介绍代码逻辑

2.1 目录

目录结构：

这里是根据voc的训练集和验证集转换，且需要xml对应的json字典文件

class_indices.json 如下：

没有的话，看这个自己生成：目标检测篇：如何根据xml标注文件生成类别classes的json文件

2.2 图像的生成

关于图片，可以直接拷贝过去就行

这里生成好的目录根据本人习惯命名

代码运行到这，可以看到图像已经拷贝过去

2.3 目标类别的txt文件生成

yolo格式的classes文件，这里默认根据voc的json字典文件生成，代码如下

代码很简单，就是读取xml的json文件，获取字典的value值，然后保存在txt文件中

2.4 标签xml to yolo标签txt

这里通过labels_xml2yolo 自定义函数操作，传入训练集和验证集的xml目录即可，因为yolo的txt文件需要类别索引，这里将字典文件也传进去

 

这里需要保存原始图像的w、h，因为yolo标注是相对值，后面运算需要。因为voc标注的xml文件中包含了图像的size，直接读取即可

下面是将bbox坐标转为yolo相对坐标的代码，最终的数据就是info的存放的内容

将info 保存即可

生成好的数据：

2.5 可视化

为了验证是否转化成功，利用 这篇代码 可视化一下

3. 完整代码

如下：

  1. import os
  2. from tqdm import tqdm
  3. from lxml import etree
  4. import shutil
  5. import json
  6.  
  7.  
  8. # 读取 xml 文件信息，并返回字典形式
  9. def parse_xml_to_dict(xml):
  10.     if len(xml) == 0:  # 遍历到底层，直接返回 tag对应的信息
  11.         return {xml.tag: xml.text}
  12.  
  13.     result = {}
  14.     for child in xml:
  15.         child_result = parse_xml_to_dict(child)  # 递归遍历标签信息
  16.         if child.tag != 'object':
  17.             result[child.tag] = child_result[child.tag]
  18.         else:
  19.             if child.tag not in result:  # 因为object可能有多个，所以需要放入列表里
  20.                 result[child.tag] = []
  21.             result[child.tag].append(child_result[child.tag])
  22.     return {xml.tag: result}
  23.  
  24.  
  25. # 将xml文件转换为yolo的 txt文件
  26. def labels_xml2yolo(src, class_dict):
  27.     xml_path = [os.path.join(src, i) for i in os.listdir(src)]
  28.     for xml_file in tqdm(xml_path):
  29.         # read xml
  30.         with open(xml_file,mode='r') as fid:
  31.             xml_str = fid.read()
  32.         xml = etree.fromstring(xml_str)
  33.         data = parse_xml_to_dict(xml)["annotation"]  # 读取xml文件信息
  34.         img_height = int(data["size"]["height"])  # 读入图像的 h
  35.         img_width = int(data["size"]["width"])  # 读入图像的 w
  36.  
  37.         # 新建 xml对应的 yolo txt标注文件，并写入
  38.         yolo_file = xml_file.replace('my_xml_dataset', 'my_yolo_dataset')
  39.         yolo_file = yolo_file.replace('.xml', '.txt')
  40.         with open(yolo_file,mode="w") as f:
  41.             for index, obj in enumerate(data["object"]):  # index是0开始的索引，obj 是object的字典文件
  42.                 # 获取每个object的box信息
  43.                 xmin = float(obj["bndbox"]["xmin"])
  44.                 xmax = float(obj["bndbox"]["xmax"])
  45.                 ymin = float(obj["bndbox"]["ymin"])
  46.                 ymax = float(obj["bndbox"]["ymax"])
  47.                 class_name = obj["name"]  # 获取边界框的分类
  48.                 class_index = class_dict[class_name]
  49.  
  50.                 # 将box信息转换到 yolo格式
  51.                 xcenter = xmin + (xmax - xmin) / 2  # 中心点坐标
  52.                 ycenter = ymin + (ymax - ymin) / 2
  53.                 w = xmax - xmin  # 边界框的 w 和 h
  54.                 h = ymax - ymin
  55.  
  56.                 # 绝对坐标转相对坐标，保存6位小数
  57.                 xcenter = round(xcenter / img_width, 6)
  58.                 ycenter = round(ycenter / img_height, 6)
  59.                 w = round(w / img_width, 6)
  60.                 h = round(h / img_height, 6)
  61.  
  62.                 info = [str(i) for i in [class_index, xcenter, ycenter, w, h]]
  63.                 # print(info)     ['0', '0.403646', '0.485491', '0.103423', '0.110863']
  64.  
  65.                 if index == 0:
  66.                     f.write(" ".join(info))
  67.                 else:  # 自动换行
  68.                     f.write("\n" + " ".join(info))
  69.  
  70.  
  71. if __name__ == "__main__":
  72.  
  73.     # 删除原先的 my_yolo_dataset 文件
  74.     if os.path.exists("my_yolo_dataset"):
  75.         shutil.rmtree("my_yolo_dataset")
  76.  
  77.     # 新建目录
  78.     os.mkdir("my_yolo_dataset")
  79.     os.mkdir("my_yolo_dataset/train")
  80.     os.mkdir("my_yolo_dataset/val")
  81.     os.mkdir("my_yolo_dataset/train/labels")
  82.     os.mkdir("my_yolo_dataset/val/labels")
  83.  
  84.     # 拷贝图片和 txt 文件
  85.     shutil.copytree('my_xml_dataset/train/images', 'my_yolo_dataset/train/images')
  86.     shutil.copytree('my_xml_dataset/val/images', 'my_yolo_dataset/val/images')
  87.  
  88.     # 生成txt类别文件
  89.     json_file = open('my_xml_dataset/class_indices.json', 'r')
  90.     class_dict = json.load(json_file)
  91.     # print(class_dict)  {'0': 'Leconte', '1': 'Boerner', '2': 'linnaeus', '3': 'armandi', '4': 'coleoptera', '5': 'acuminatus', '6': 'Linnaeus'}
  92.  
  93.     classes = {}
  94.     for i in range(len(class_dict)):
  95.         classes[i] = class_dict[str(i)]
  96.     classes = {str(v): str(k) for k, v in classes.items()}
  97.     # print(classes)  {'Leconte': '0', 'Boerner': '1', 'linnaeus': '2', 'armandi': '3', 'coleoptera': '4', 'acuminatus': '5', 'Linnaeus': '6'}
  98.  
  99.     txt = classes.keys()        # yolo 的txt
  100.     # print(txt)  dict_keys(['Leconte', 'Boerner', 'linnaeus', 'armandi', 'coleoptera', 'acuminatus', 'Linnaeus'])
  101.  
  102.     with open('./my_yolo_dataset/classes.txt','w') as f:
  103.         for i in txt:
  104.             f.write(i)
  105.             f.write('\n')
  106.  
  107.     # 将xml 标注信息更改为 yolo 格式
  108.     labels_xml2yolo(src='my_xml_dataset/train/labels', class_dict=classes)
  109.     labels_xml2yolo(src='my_xml_dataset/val/labels', class_dict=classes)

4. 附加代码

如果xml文件没有图片的size信息，用这个代码，会自动读取图片高度和宽度。并且会剔除xml文件种没有目标的部分

  1. import os
  2. from tqdm import tqdm
  3. from lxml import etree
  4. import shutil
  5. import json
  6. import cv2
  7.  
  8.  
  9. # 读取 xml 文件信息，并返回字典形式
  10. def parse_xml_to_dict(xml):
  11.     if len(xml) == 0:  # 遍历到底层，直接返回 tag对应的信息
  12.         return {xml.tag: xml.text}
  13.  
  14.     result = {}
  15.     for child in xml:
  16.         child_result = parse_xml_to_dict(child)  # 递归遍历标签信息
  17.         if child.tag != 'object':
  18.             result[child.tag] = child_result[child.tag]
  19.         else:
  20.             if child.tag not in result:  # 因为object可能有多个，所以需要放入列表里
  21.                 result[child.tag] = []
  22.             result[child.tag].append(child_result[child.tag])
  23.     return {xml.tag: result}
  24.  
  25.  
  26. # 将xml文件转换为yolo的 txt文件
  27. def labels_xml2yolo(src, class_dict):
  28.     xml_path = [os.path.join(src, i) for i in os.listdir(src)]
  29.     for xml_file in tqdm(xml_path):
  30.         # read xml
  31.         with open(xml_file, mode='r') as fid:
  32.             xml_str = fid.read()
  33.         xml = etree.fromstring(xml_str)
  34.         data = parse_xml_to_dict(xml)["annotation"]  # 读取xml文件信息
  35.  
  36.         if 'object' not in data.keys():  # 移除不存在边界框的数据
  37.             continue
  38.  
  39.         # 读取图片
  40.         img_path = xml_file.replace('labels','images')
  41.         img_path = img_path.replace('.xml','.jpg')      # 根据后缀更换
  42.         img = cv2.imread(img_path)
  43.         img_height,img_width = img.shape[:2]
  44.  
  45.         # 新建 xml对应的 yolo txt标注文件，并写入
  46.         yolo_file = xml_file.replace('data', 'my_yolo_dataset')
  47.         yolo_file = yolo_file.replace('.xml', '.txt')
  48.  
  49.         with open(yolo_file, mode="w") as f:
  50.             for index, obj in enumerate(data["object"]):  # index是0开始的索引，obj 是object的字典文件
  51.                 # 拷贝图片
  52.                 shutil.copy(img_path, src.replace('data','my_yolo_dataset').replace('labels','images'))
  53.  
  54.                 # 获取每个object的box信息
  55.                 xmin = float(obj["bndbox"]["xmin"])
  56.                 xmax = float(obj["bndbox"]["xmax"])
  57.                 ymin = float(obj["bndbox"]["ymin"])
  58.                 ymax = float(obj["bndbox"]["ymax"])
  59.                 class_name = obj["label"]  # 获取边界框的分类
  60.                 class_index = class_dict[class_name]
  61.  
  62.                 # 将box信息转换到 yolo格式
  63.                 xcenter = xmin + (xmax - xmin) / 2  # 中心点坐标
  64.                 ycenter = ymin + (ymax - ymin) / 2
  65.                 w = xmax - xmin  # 边界框的 w 和 h
  66.                 h = ymax - ymin
  67.  
  68.                 # 绝对坐标转相对坐标，保存6位小数
  69.                 xcenter = round(xcenter / img_width, 6)
  70.                 ycenter = round(ycenter / img_height, 6)
  71.                 w = round(w / img_width, 6)
  72.                 h = round(h / img_height, 6)
  73.  
  74.                 info = [str(i) for i in [class_index, xcenter, ycenter, w, h]]
  75.                 # print(info)     ['0', '0.403646', '0.485491', '0.103423', '0.110863']
  76.  
  77.                 if index == 0:
  78.                     f.write(" ".join(info))
  79.                 else:  # 自动换行
  80.                     f.write("\n" + " ".join(info))
  81.  
  82.  
  83. if __name__ == "__main__":
  84.  
  85.     # 删除原先的 my_yolo_dataset 文件
  86.     if os.path.exists("my_yolo_dataset"):
  87.         shutil.rmtree("my_yolo_dataset")
  88.  
  89.     # 新建目录
  90.     os.mkdir("my_yolo_dataset")
  91.     os.mkdir("my_yolo_dataset/train")
  92.     os.mkdir("my_yolo_dataset/test")
  93.     os.mkdir("my_yolo_dataset/train/labels")
  94.     os.mkdir("my_yolo_dataset/train/images")
  95.     os.mkdir("my_yolo_dataset/test/labels")
  96.     os.mkdir("my_yolo_dataset/test/images")
  97.  
  98.     # 生成txt类别文件
  99.     json_file = open('class_indices.json', 'r')
  100.     class_dict = json.load(json_file)
  101.     # print(class_dict)  {'0': 'Leconte', '1': 'Boerner', '2': 'linnaeus', '3': 'armandi', '4': 'coleoptera', '5': 'acuminatus', '6': 'Linnaeus'}
  102.  
  103.     classes = {}
  104.     for i in range(len(class_dict)):
  105.         classes[i] = class_dict[str(i)]
  106.     classes = {str(v): str(k) for k, v in classes.items()}
  107.     # print(classes)  {'Leconte': '0', 'Boerner': '1', 'linnaeus': '2', 'armandi': '3', 'coleoptera': '4', 'acuminatus': '5', 'Linnaeus': '6'}
  108.  
  109.     txt = classes.keys()  # yolo 的txt
  110.     # print(txt)  dict_keys(['Leconte', 'Boerner', 'linnaeus', 'armandi', 'coleoptera', 'acuminatus', 'Linnaeus'])
  111.  
  112.     with open('./my_yolo_dataset/classes.txt', 'w') as f:
  113.         for i in txt:
  114.             f.write(i)
  115.             f.write('\n')
  116.  
  117.     # 将xml 标注信息更改为 yolo 格式
  118.     labels_xml2yolo(src='data/train/labels', class_dict=classes)
  119.     labels_xml2yolo(src='data/test/labels', class_dict=classes)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/189628
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号