Pascal VOC数据格式转COCO数据格式脚本（Object Detection）

妖狐艹你老母 2022-01-30 14:59 489阅读 0赞

# 1. 前言 #

## 1.1 COCO数据集 ##

COCO的全称是Common Objects in COntext，是微软团队提供的一个可以用来进行图像识别的数据集。MS COCO数据集中的图像分为训练、验证和测试集。COCO通过在Flickr上搜索80个对象类别和各种场景类型来收集图像，其使用了亚马逊的Mechanical Turk（AMT）来收集数据。COCO数据集现在有3种标注类型：**object instances（目标实例）, object keypoints（目标上的关键点）, and image captions（看图说话）**，使用JSON文件存储。

## 1.2 COCO数据基本结构 ##

这3种类型共享下面所列的基本类型，包括info、image、license，而annotation类型则呈现出了多态，会根据不同的任务具有不同的数据标注形式。

{ 
    "info" : info,
    "images" : [image], 
    "annotations" : [annotation],
    "licenses" : [license],
    }
    
    info{ 
    "year" : int,
    "version" : str,
    "description" : str,
    "contributor" : str,
    "url" : str,
    "date_created" : datetime,
    }
    
    image{ 
    "id" : int,
    "width" : int,
    "height" : int,
    "file_name" : str,
    "license" : int,
    "flickr_url" : str,
    "coco_url" : str,
    "date_captured" : datetime,
    }
    
    license{ 
    "id" : int,
    "name" : str,
    "url" : str,
    }

除了Annotation数据之外的数据类型举例如下：  
1）**info类型**，比如一个info类型的实例：

"info":{ 
    	"description":"This is stable 1.0 version of the 2014 MS COCO dataset.",
    	"url":"http:\/\/mscoco.org",
    	"version":"1.0","year":2014,
    	"contributor":"Microsoft COCO group",
    	"date_created":"2015-01-27 09:11:52.357475"
    }

2）**Images类型**，Images是包含多个image实例的数组，对于一个image类型的实例：

{ 
    	"license":3,
    	"file_name":"COCO_val2014_000000391895.jpg",
    	"coco_url":"http:\/\/mscoco.org\/images\/391895",
    	"height":360,"width":640,"date_captured":"2013-11-14 11:18:45",
    	"flickr_url":"http:\/\/farm9.staticflickr.com\/8186\/8119368305_4e622c8349_z.jpg",
    	"id":391895
    }

3）**licenses类型**，licenses是包含多个license实例的数组，对于一个license类型的实例：

{ 
    	"url":"http:\/\/creativecommons.org\/licenses\/by-nc-sa\/2.0\/",
    	"id":1,
    	"name":"Attribution-NonCommercial-ShareAlike License"
    }

## 1.3 Object Instance 类型的标注格式 ##

1）**整体JSON文件格式**  
Object Instance这种格式的文件从头至尾按照顺序分为以下段落：

{ 
        "info": info,
        "licenses": [license],
        "images": [image],
        "annotations": [annotation],
        "categories": [category]
    }

是的，你打开这两个文件，虽然内容很多，但从文件开始到结尾按照顺序就是这5段。其中，info、licenses、images这三个结构体/类型 在上一节中已经说了，在不同的JSON文件中这三个类型是一样的，定义是共享的。不共享的是annotation和category这两种结构体，他们在不同类型的JSON文件中是不一样的。

**PS**，mages数组、annotations数组、categories数组的元素数量是相等的，等于图片的数量。

2）**annotations字段**  
annotations字段是包含多个annotation实例的一个数组，annotation类型本身又包含了一系列的字段，如这个目标的category id和segmentation mask。segmentation格式取决于这个实例是一个单个的对象（即iscrowd=0，将使用polygons格式）还是一组对象（即iscrowd=1，将使用RLE格式）。如下所示：

annotation{ 
        "id": int,
        "image_id": int,
        "category_id": int,
        "segmentation": RLE or [polygon],
        "area": float,
        "bbox": [x,y,width,height],
        "iscrowd": 0 or 1,
    }

注意，单个的对象（iscrowd=0)可能需要多个polygon来表示，比如这个对象在图像中被挡住了。而iscrowd=1时（将标注一组对象，比如一群人）的segmentation使用的就是RLE格式。

另外，每个对象（不管是iscrowd=0还是iscrowd=1）都会有一个矩形框bbox ，矩形框左上角的坐标和矩形框的长宽会以数组的形式提供，数组第一个元素就是左上角的横坐标值。

其中，area是框的面积（area of encoded masks）。

3）**categories字段**  
annotation结构中的categories字段存储的是当前对象所属的category的id，以及所属的supercategory的name。  
categories是一个包含多个category实例的数组，而category结构体描述如下：

{ 
        "id": int,
        "name": str,
        "supercategory": str,
    }

从instances\_val2017.json文件中摘出的2个category实例如下所示：

{ 
    	"supercategory": "person",
    	"id": 1,
    	"name": "person"
    },
    { 
    	"supercategory": "vehicle",
    	"id": 2,
    	"name": "bicycle"
    },
    ......

# 2. 转换脚本 #

# -*- coding=utf-8 -*-
    #!/usr/bin/python
    
    import sys
    import os
    import shutil
    import numpy as np
    import json
    import xml.etree.ElementTree as ET
    
    # 检测框的ID起始值
    START_BOUNDING_BOX_ID = 1
    # 类别列表无必要预先创建，程序中会根据所有图像中包含的ID来创建并更新
    PRE_DEFINE_CATEGORIES = { }
    # If necessary, pre-define category and its id
    # PRE_DEFINE_CATEGORIES = {"aeroplane": 1, "bicycle": 2, "bird": 3, "boat": 4,
                             # "bottle":5, "bus": 6, "car": 7, "cat": 8, "chair": 9,
                             # "cow": 10, "diningtable": 11, "dog": 12, "horse": 13,
                             # "motorbike": 14, "person": 15, "pottedplant": 16,
                             # "sheep": 17, "sofa": 18, "train": 19, "tvmonitor": 20}
    
    
    def get(root, name):
        vars = root.findall(name)
        return vars
    
    
    def get_and_check(root, name, length):
        vars = root.findall(name)
        if len(vars) == 0:
            raise NotImplementedError('Can not find %s in %s.'%(name, root.tag))
        if length > 0 and len(vars) != length:
            raise NotImplementedError('The size of %s is supposed to be %d, but is %d.'%(name, length, len(vars)))
        if length == 1:
            vars = vars[0]
        return vars
    
    
    # 得到图片唯一标识号
    def get_filename_as_int(filename):
        try:
            filename = os.path.splitext(filename)[0]
            return int(filename)
        except:
            raise NotImplementedError('Filename %s is supposed to be an integer.'%(filename))
    
    
    def convert(xml_list, xml_dir, json_file):
        ''' :param xml_list: 需要转换的XML文件列表 :param xml_dir: XML的存储文件夹 :param json_file: 导出json文件的路径 :return: None '''
        list_fp = xml_list
        # 标注基本结构
        json_dict = { "images":[],
                     "type": "instances",
                     "annotations": [],
                     "categories": []}
        categories = PRE_DEFINE_CATEGORIES
        bnd_id = START_BOUNDING_BOX_ID
        for line in list_fp:
            line = line.strip()
            print("buddy~ Processing {}".format(line))
            # 解析XML
            xml_f = os.path.join(xml_dir, line)
            tree = ET.parse(xml_f)
            root = tree.getroot()
            path = get(root, 'path')
            # 取出图片名字
            if len(path) == 1:
                filename = os.path.basename(path[0].text)
            elif len(path) == 0:
                filename = get_and_check(root, 'filename', 1).text
            else:
                raise NotImplementedError('%d paths found in %s'%(len(path), line))
            ## The filename must be a number
            image_id = get_filename_as_int(filename)  # 图片ID
            size = get_and_check(root, 'size', 1)
            # 图片的基本信息
            width = int(get_and_check(size, 'width', 1).text)
            height = int(get_and_check(size, 'height', 1).text)
            image = { 'file_name': filename,
                     'height': height,
                     'width': width,
                     'id':image_id}
            json_dict['images'].append(image)
            ## Cruuently we do not support segmentation
            # segmented = get_and_check(root, 'segmented', 1).text
            # assert segmented == '0'
            # 处理每个标注的检测框
            for obj in get(root, 'object'):
                # 取出检测框类别名称
                category = get_and_check(obj, 'name', 1).text
                # 更新类别ID字典
                if category not in categories:
                    new_id = len(categories)
                    categories[category] = new_id
                category_id = categories[category]
                bndbox = get_and_check(obj, 'bndbox', 1)
                xmin = int(get_and_check(bndbox, 'xmin', 1).text) - 1
                ymin = int(get_and_check(bndbox, 'ymin', 1).text) - 1
                xmax = int(get_and_check(bndbox, 'xmax', 1).text)
                ymax = int(get_and_check(bndbox, 'ymax', 1).text)
                assert(xmax > xmin)
                assert(ymax > ymin)
                o_width = abs(xmax - xmin)
                o_height = abs(ymax - ymin)
                annotation = dict()
                annotation['area'] = o_width*o_height
                annotation['iscrowd'] = 0
                annotation['image_id'] = image_id
                annotation['bbox'] = [xmin, ymin, o_width, o_height]
                annotation['category_id'] = category_id
                annotation['id'] = bnd_id
                annotation['ignore'] = 0
                # 设置分割数据，点的顺序为逆时针方向
                annotation['segmentation'] = [[xmin,ymin,xmin,ymax,xmax,ymax,xmax,ymin]]
    
                json_dict['annotations'].append(annotation)
                bnd_id = bnd_id + 1
    
        # 写入类别ID字典
        for cate, cid in categories.items():
            cat = { 'supercategory': 'none', 'id': cid, 'name': cate}
            json_dict['categories'].append(cat)
        # 导出到json
        json_fp = open(json_file, 'w')
        json_str = json.dumps(json_dict)
        json_fp.write(json_str)
        json_fp.close()
    
    
    if __name__ == '__main__':
        root_path = os.getcwd()
        xml_dir = os.path.join(root_path, 'Annotations')
    
        xml_labels = os.listdir(os.path.join(root_path, 'Annotations'))
        np.random.shuffle(xml_labels)
        split_point = int(len(xml_labels)/10)
    
        # validation data
        xml_list = xml_labels[0:split_point]
        json_file = './instances_val2014.json'
        convert(xml_list, xml_dir, json_file)
        for xml_file in xml_list:
            img_name = xml_file[:-4] + '.jpg'
            shutil.copy(os.path.join(root_path, 'JPEGImages', img_name),
                        os.path.join(root_path, 'val2014', img_name))
        # train data
        xml_list = xml_labels[split_point:]
        json_file = './instances_train2014.json'
        convert(xml_list, xml_dir, json_file)
        for xml_file in xml_list:
            img_name = xml_file[:-4] + '.jpg'
            shutil.copy(os.path.join(root_path, 'JPEGImages', img_name),
                        os.path.join(root_path, 'train2014', img_name))

# 3. Reference #

1.  [COCO官网解释][COCO]
2.  [COCO数据集的标注格式][COCO 1]

[COCO]: http://cocodataset.org/#format-data
[COCO 1]: https://blog.csdn.net/gqixf/article/details/79280224