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

有手就行的自定义制作coco、voc、yolo格式数据集_voc数据集制作软件

作者：花生_TL007 | 2024-04-23 18:42:59

赞

踩

voc数据集制作软件

目录

1. 准备工作

2. 开始打标注  

 3. 转换为coco格式

4. 转换为voc格式 

5. 转换为yolo格式

1. 准备工作

    （1）安装软件labelme，自行安装，不再说明。

    （2）准备好原始图片，本文以10张图片如下图所示，用labelme软件打标签

2. 开始打标注  

         首先打开labelme软件 ，然后打开目录，定位到你数据源所在的文件夹

                               

 用矩形框打标注，这里只标注两个类别：mask、person

 

打完标注后保存图片，保存后得到的json文件名字要和图片名字一次，点击NextImage继续下一张图片打标注，直至所有图片打完标注。

 待所有10张图片打完标签，得到如下结果，接着需要根据json文件分别转换为coco、voc、yolo格式的数据集。

 

 3. 转换为coco格式

     转换cooc格式，把上面的json文件复制到原来的图片文件夹source-ing中,因为需要把图片划分为训练集和验证集。

 下面是转换代码json -> coco

  1. import os
  2. import json
  3. import numpy as np
  4. import glob
  5. import shutil
  6. import cv2
  7. from sklearn.model_selection import train_test_split
  8.  
  9. np.random.seed(41)
  10.  
  11. classname_to_id = {
  12.     "mask": 0, #改成自己的类别
  13.     "person": 1
  14. }
  15.  
  16.  
  17. class Lableme2CoCo:
  18.  
  19.     def __init__(self):
  20.         self.images = []
  21.         self.annotations = []
  22.         self.categories = []
  23.         self.img_id = 0
  24.         self.ann_id = 0
  25.  
  26.     def save_coco_json(self, instance, save_path):
  27.         json.dump(instance, open(save_path, 'w', encoding='utf-8'), ensure_ascii=False, indent=1)  # indent=2 更加美观显示
  28.  
  29.     # 由json文件构建COCO
  30.     def to_coco(self, json_path_list):
  31.         self._init_categories()
  32.         for json_path in json_path_list:
  33.             obj = self.read_jsonfile(json_path)
  34.             self.images.append(self._image(obj, json_path))
  35.             shapes = obj['shapes']
  36.             for shape in shapes:
  37.                 annotation = self._annotation(shape)
  38.                 self.annotations.append(annotation)
  39.                 self.ann_id += 1
  40.             self.img_id += 1
  41.         instance = {}
  42.         instance['info'] = 'spytensor created'
  43.         instance['license'] = ['license']
  44.         instance['images'] = self.images
  45.         instance['annotations'] = self.annotations
  46.         instance['categories'] = self.categories
  47.         return instance
  48.  
  49.     # 构建类别
  50.     def _init_categories(self):
  51.         for k, v in classname_to_id.items():
  52.             category = {}
  53.             category['id'] = v
  54.             category['name'] = k
  55.             self.categories.append(category)
  56.  
  57.     # 构建COCO的image字段
  58.     def _image(self, obj, path):
  59.         image = {}
  60.         from labelme import utils
  61.         img_x = utils.img_b64_to_arr(obj['imageData'])
  62.         h, w = img_x.shape[:-1]
  63.         image['height'] = h
  64.         image['width'] = w
  65.         image['id'] = self.img_id
  66.         image['file_name'] = os.path.basename(path).replace(".json", ".jpg")
  67.         return image
  68.  
  69.     # 构建COCO的annotation字段
  70.     def _annotation(self, shape):
  71.         # print('shape', shape)
  72.         label = shape['label']
  73.         points = shape['points']
  74.         annotation = {}
  75.         annotation['id'] = self.ann_id
  76.         annotation['image_id'] = self.img_id
  77.         annotation['category_id'] = int(classname_to_id[label])
  78.         annotation['segmentation'] = [np.asarray(points).flatten().tolist()]
  79.         annotation['bbox'] = self._get_box(points)
  80.         annotation['iscrowd'] = 0
  81.         annotation['area'] = 1.0
  82.         return annotation
  83.  
  84.     # 读取json文件，返回一个json对象
  85.     def read_jsonfile(self, path):
  86.         with open(path, "r", encoding='utf-8') as f:
  87.             return json.load(f)
  88.  
  89.     # COCO的格式： [x1,y1,w,h] 对应COCO的bbox格式
  90.     def _get_box(self, points):
  91.         min_x = min_y = np.inf
  92.         max_x = max_y = 0
  93.         for x, y in points:
  94.             min_x = min(min_x, x)
  95.             min_y = min(min_y, y)
  96.             max_x = max(max_x, x)
  97.             max_y = max(max_y, y)
  98.         return [min_x, min_y, max_x - min_x, max_y - min_y]
  99.  
  100. #训练过程中，如果遇到Index put requires the source and destination dtypes match, got Long for the destination and Int for the source
  101. #参考：https://github.com/open-mmlab/mmdetection/issues/6706
  102. if __name__ == '__main__':
  103.     labelme_path = "./source-img"  #json和图片的存放目录
  104.     saved_coco_path = "./data-"    #生成coco格式数据的保存文件夹名字
  105.     print('reading...')
  106.     # 创建文件
  107.     if not os.path.exists("%scoco/annotations/" % saved_coco_path):
  108.         os.makedirs("%scoco/annotations/" % saved_coco_path)
  109.     if not os.path.exists("%scoco/images/train/" % saved_coco_path):
  110.         os.makedirs("%scoco/images/train" % saved_coco_path)
  111.     if not os.path.exists("%scoco/images/val/" % saved_coco_path):
  112.         os.makedirs("%scoco/images/val" % saved_coco_path)
  113.     # 获取images目录下所有的joson文件列表
  114.     print(labelme_path + "/*.json")
  115.     json_list_path = glob.glob(labelme_path + "/*.json")
  116.     print('json_list_path: ', len(json_list_path))
  117.     # 数据划分,这里没有区分val2017和tran2017目录，所有图片都放在images目录下
  118.     train_path, val_path = train_test_split(json_list_path, test_size=0.2, train_size=0.8)
  119.     print("train_n:", len(train_path), 'val_n:', len(val_path))
  120.  
  121.     # 把训练集转化为COCO的json格式
  122.     l2c_train = Lableme2CoCo()
  123.     train_instance = l2c_train.to_coco(train_path)
  124.     l2c_train.save_coco_json(train_instance, '%scoco/annotations/instances_train.json' % saved_coco_path)
  125.     for file in train_path:
  126.         # shutil.copy(file.replace("json", "jpg"), "%scoco/images/train2017/" % saved_coco_path)
  127.         img_name = file.replace('json', 'jpg')
  128.         temp_img = cv2.imread(img_name)
  129.         try:
  130.             cv2.imwrite("{}coco/images/train/{}".format(saved_coco_path, img_name.split('\\')[-1].replace('png', 'jpg')), temp_img)
  131.         except Exception as e:
  132.             print(e)
  133.             print('Wrong Image:', img_name )
  134.             continue
  135.         print(img_name + '-->', img_name.replace('png', 'jpg'))
  136.  
  137.     for file in val_path:
  138.         # shutil.copy(file.replace("json", "jpg"), "%scoco/images/val2017/" % saved_coco_path)
  139.         img_name = file.replace('json', 'jpg')
  140.         temp_img = cv2.imread(img_name)
  141.         try:
  142.             cv2.imwrite("{}coco/images/val/{}".format(saved_coco_path, img_name.split('\\')[-1].replace('png', 'jpg')), temp_img)
  143.         except Exception as e:
  144.             print(e)
  145.             print('Wrong Image:', img_name)
  146.             continue
  147.         print(img_name + '-->', img_name.replace('png', 'jpg'))
  148.  
  149.     # 把验证集转化为COCO的json格式
  150.     l2c_val = Lableme2CoCo()
  151.     val_instance = l2c_val.to_coco(val_path)
  152.     l2c_val.save_coco_json(val_instance, '%scoco/annotations/instances_val.json' % saved_coco_path)
  153.

 生成的coco数据集文件夹为data-coco，原代码中train和val的比例为8：2(比例可在代码中修改)，所以train有8张图片，val有2张图片。

4. 转换为voc格式 

        转换代码在本小节最下面，需要给脚本传递3个参数：

    输入数据集数据文件夹   转换结果存放的文件夹名字    --labels   label文件

        输入数据集数据文件夹：就是上面source-img

        转换结果存放的文件夹名字: 就是转换成voc格式后的数据保存路径名字，这个路径是程序自己创建的，不需要我们事先创建，我们只是传递名字给脚本。

         label文件：内容是类别的名字，格式如下

         以本文为例，传递参数这样写   source-img  voc-data   --labels   labels.txt

       pycharm 编译配置参数：

         label文件内容

  1. __ignore__
  2. _background_
  3. mask
  4. person

        转换成voc脚本代码 

  1. #!/usr/bin/env python
  2.  
  3. from __future__ import print_function
  4.  
  5. import argparse
  6. import glob
  7. import os
  8. import os.path as osp
  9. import sys
  10.  
  11. import imgviz
  12. import numpy as np
  13.  
  14. import labelme
  15.  
  16. #传递参数3个： 输入数据文件夹 转换结果文件夹名字 --labels   label文件
  17. #如   source-img  voc-data  --labels labels.txt
  18. def main():
  19.     parser = argparse.ArgumentParser(
  20.         formatter_class=argparse.ArgumentDefaultsHelpFormatter
  21.     )
  22.     parser.add_argument("input_dir", help="input annotated directory")
  23.     parser.add_argument("output_dir", help="output dataset directory")
  24.     parser.add_argument("--labels", help="labels file", required=True)
  25.     parser.add_argument(
  26.         "--noviz", help="no visualization", action="store_true"
  27.     )
  28.     args = parser.parse_args()
  29.  
  30.     if osp.exists(args.output_dir):
  31.         print("Output directory already exists:", args.output_dir)
  32.         sys.exit(1)
  33.     os.makedirs(args.output_dir)
  34.     os.makedirs(osp.join(args.output_dir, "JPEGImages"))
  35.     os.makedirs(osp.join(args.output_dir, "SegmentationClass"))
  36.     os.makedirs(osp.join(args.output_dir, "SegmentationClassPNG"))
  37.     if not args.noviz:
  38.         os.makedirs(
  39.             osp.join(args.output_dir, "SegmentationClassVisualization")
  40.         )
  41.     os.makedirs(osp.join(args.output_dir, "SegmentationObject"))
  42.     os.makedirs(osp.join(args.output_dir, "SegmentationObjectPNG"))
  43.     if not args.noviz:
  44.         os.makedirs(
  45.             osp.join(args.output_dir, "SegmentationObjectVisualization")
  46.         )
  47.     print("Creating dataset:", args.output_dir)
  48.  
  49.     class_names = []
  50.     class_name_to_id = {}
  51.     for i, line in enumerate(open(args.labels).readlines()):
  52.         class_id = i - 1  # starts with -1
  53.         class_name = line.strip()
  54.         class_name_to_id[class_name] = class_id
  55.         if class_id == -1:
  56.             assert class_name == "__ignore__"
  57.             continue
  58.         elif class_id == 0:
  59.             assert class_name == "_background_"
  60.         class_names.append(class_name)
  61.     class_names = tuple(class_names)
  62.     print("class_names:", class_names)
  63.     out_class_names_file = osp.join(args.output_dir, "class_names.txt")
  64.     with open(out_class_names_file, "w") as f:
  65.         f.writelines("\n".join(class_names))
  66.     print("Saved class_names:", out_class_names_file)
  67.  
  68.     for filename in glob.glob(osp.join(args.input_dir, "*.json")):
  69.         print("Generating dataset from:", filename)
  70.  
  71.         label_file = labelme.LabelFile(filename=filename)
  72.  
  73.         base = osp.splitext(osp.basename(filename))[0]
  74.         out_img_file = osp.join(args.output_dir, "JPEGImages", base + ".jpg")
  75.         out_cls_file = osp.join(
  76.             args.output_dir, "SegmentationClass", base + ".npy"
  77.         )
  78.         out_clsp_file = osp.join(
  79.             args.output_dir, "SegmentationClassPNG", base + ".png"
  80.         )
  81.         if not args.noviz:
  82.             out_clsv_file = osp.join(
  83.                 args.output_dir,
  84.                 "SegmentationClassVisualization",
  85.                 base + ".jpg",
  86.             )
  87.         out_ins_file = osp.join(
  88.             args.output_dir, "SegmentationObject", base + ".npy"
  89.         )
  90.         out_insp_file = osp.join(
  91.             args.output_dir, "SegmentationObjectPNG", base + ".png"
  92.         )
  93.         if not args.noviz:
  94.             out_insv_file = osp.join(
  95.                 args.output_dir,
  96.                 "SegmentationObjectVisualization",
  97.                 base + ".jpg",
  98.             )
  99.  
  100.         img = labelme.utils.img_data_to_arr(label_file.imageData)
  101.         imgviz.io.imsave(out_img_file, img)
  102.  
  103.         cls, ins = labelme.utils.shapes_to_label(
  104.             img_shape=img.shape,
  105.             shapes=label_file.shapes,
  106.             label_name_to_value=class_name_to_id,
  107.         )
  108.         ins[cls == -1] = 0  # ignore it.
  109.  
  110.         # class label
  111.         labelme.utils.lblsave(out_clsp_file, cls)
  112.         np.save(out_cls_file, cls)
  113.         if not args.noviz:
  114.             clsv = imgviz.label2rgb(
  115.                 cls,
  116.                 imgviz.rgb2gray(img),
  117.                 label_names=class_names,
  118.                 font_size=15,
  119.                 loc="rb",
  120.             )
  121.             imgviz.io.imsave(out_clsv_file, clsv)
  122.  
  123.         # instance label
  124.         labelme.utils.lblsave(out_insp_file, ins)
  125.         np.save(out_ins_file, ins)
  126.         if not args.noviz:
  127.             instance_ids = np.unique(ins)
  128.             instance_names = [str(i) for i in range(max(instance_ids) + 1)]
  129.             insv = imgviz.label2rgb(
  130.                 ins,
  131.                 imgviz.rgb2gray(img),
  132.                 label_names=instance_names,
  133.                 font_size=15,
  134.                 loc="rb",
  135.             )
  136.             imgviz.io.imsave(out_insv_file, insv)
  137.  
  138.  
  139. if __name__ == "__main__":
  140.     main()
5. 转换为yolo格式

        指定类别，labelme生成的json文件所在路径，和输出保存的路径即可，直接在代码里写，然后直接编译即可

  

 

  1.  
  2. import json
  3. import os
  4. #自己打标签有多少类别就写在这里
  5. name2id = {'mask':0,'person':1}
  6.                
  7. def convert(img_size, box):
  8.     dw = 1./(img_size[0])
  9.     dh = 1./(img_size[1])
  10.     x = (box[0] + box[2])/2.0 - 1
  11.     y = (box[1] + box[3])/2.0 - 1
  12.     w = box[2] - box[0]
  13.     h = box[3] - box[1]
  14.     x = x*dw
  15.     w = w*dw
  16.     y = y*dh
  17.     h = h*dh
  18.     return (x,y,w,h)
  19.  
  20. #
  21. def decode_json(json_floder_path,json_name):
  22.     #转换好的标签放哪里
  23.     txt_name = 'D:/deep_learn/user-define-data/yolo-data/' + json_name[0:-5] + '.txt'
  24.     txt_file = open(txt_name, 'w')
  25.  
  26.     json_path = os.path.join(json_floder_path, json_name)
  27.     data = json.load(open(json_path, 'r', encoding='gb2312'))
  28.  
  29.     img_w = data['imageWidth']
  30.     img_h = data['imageHeight']
  31.  
  32.     for i in data['shapes']:
  33.         
  34.         label_name = i['label']
  35.         if (i['shape_type'] == 'rectangle'):
  36.  
  37.             x1 = int(i['points'][0][0])
  38.             y1 = int(i['points'][0][1])
  39.             x2 = int(i['points'][1][0])
  40.             y2 = int(i['points'][1][1])
  41.  
  42.             bb = (x1,y1,x2,y2)
  43.             bbox = convert((img_w,img_h),bb)
  44.             txt_file.write(str(name2id[label_name]) + " " + " ".join([str(a) for a in bbox]) + '\n')
  45. #
  46. if __name__ == "__main__":
  47.     #labelme生成标签后的数据路径，json文件路径
  48.     json_floder_path = 'D:/deep_learn/user-define-data/labelme-data'
  49.     json_names = os.listdir(json_floder_path)
  50.     for json_name in json_names:
  51.         decode_json(json_floder_path,json_name)

        下面就是转换完成后的yolo格式数据 

 

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

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

  

闽ICP备14008679号