无人机航拍图像数据集汇总

Table of Contents

引言

最近的项目涉及到对无人机航拍图像的目标检测，检测的目标包含车辆、人、无人机、船舶，比较热门的航拍数据集大多是遥感图像的数据集，与本项目相关的数据集查找不易，本文分享一下相关的航拍数据数据集，以及数据集的处理方法。

文中部分数据集已经下载，需要获取文中涉及到的数据集请私信（目录中的文件名是本人为了方便自己定义的）

数据集处理

1、获取感兴趣的类别

在训练过程中，数据集中的部分类别使用不到，需要提取中感兴趣的类别,如果以图像中没有感兴趣的类别，将图像舍弃,如果图像中既有感兴趣的类别也有不感兴趣的类别，则将不感兴趣的类别从标签文件中删除，只保存感兴趣的类别信息

import os
import shutil
#voc格式标签的地址
ann_filepath='VOCdevkit/VOC2012/Annotations/'
#原图像的地址
img_filepath='VOCdevkit/VOC2012/JPEGImages/'
#转换后图像的存放地址
img_savepath='VOCdevkit/VOC2012/JPEGImages_ssd/'
#转换后标签的存放地址
ann_savepath='VOCdevkit/VOC2007/Annotations_ssd/'
if not os.path.exists(img_savepath):
    os.mkdir(img_savepath)
 
if not os.path.exists(ann_savepath):
    os.mkdir(ann_savepath)
names = locals()

#数据集中所有的类别，类别名称要与标签号对应，如aeroplane对应name_id为0，将其放在第一个位置
#以voc数据集为例如下24~27
classes = ['aeroplane','bicycle','bird', 'boat', 'bottle',
           'bus', 'car', 'cat', 'chair', 'cow','diningtable',
           'dog', 'horse', 'motorbike', 'pottedplant',
           'sheep', 'sofa', 'train', 'tvmonitor', 'person']
 
 
for file in os.listdir(ann_filepath):
    print(file)
    fp = open(ann_filepath +  file)
    ann_savefile=ann_savepath+file
    fp_w = open(ann_savefile, 'w')
    lines = fp.readlines()
 
    ind_start = []
    ind_end = []
    lines_id_start = lines[:]
    lines_id_end = lines[:]
 
 #设置感兴趣的类别：classesn = '\t\t<name>RoiClassName</name>\n'
 #RoiClassName为具体的类别名称
    classes1 = '\t\t<name>aeroplane</name>\n'
    classes2 = '\t\t<name>boat</name>\n'
    classes3 = '\t\t<name>bus</name>\n'
    classes4 = '\t\t<name>car</name>\n'
    classes5 = '\t\t<name>person</name>\n'
 
    #在xml中找到object块，并将其记录下来
    while "\t<object>\n" in lines_id_start:
        a = lines_id_start.index("\t<object>\n")
        ind_start.append(a)
        lines_id_start[a] = "delete"
 
 
    while "\t</object>\n" in lines_id_end:
        b = lines_id_end.index("\t</object>\n")
        ind_end.append(b)
        lines_id_end[b] = "delete"
 
    #names中存放所有的object块
    i = 0
    for k in range(0, len(ind_start)):
        names['block%d' % k] = []
        for j in range(0, len(classes)):
            if classes[j] in lines[ind_start[i] + 1]:
                a = ind_start[i]
                for o in range(ind_end[i] - ind_start[i] + 1):
                    names['block%d' % k].append(lines[a + o])
                break
        i += 1
        #print(names['block%d' % k])
 
 
    #xml头
    string_start = lines[0:ind_start[0]]
    #xml尾
    string_end = [lines[len(lines) - 1]]
 
 
    #在给定的类中搜索，若存在则，写入object块信息
    a = 0
    for k in range(0, len(ind_start)):
        if classes1 in names['block%d' % k]:
            a += 1
            string_start += names['block%d' % k]
        if classes2 in names['block%d' % k]:
            a += 1
            string_start += names['block%d' % k]
        if classes3 in names['block%d' % k]:
            a += 1
            string_start += names['block%d' % k]
        if classes4 in names['block%d' % k]:
            a += 1
            string_start += names['block%d' % k]
        if classes5 in names['block%d' % k]:
            a += 1
            string_start += names['block%d' % k]
    string_start += string_end
    for c in range(0, len(string_start)):
        fp_w.write(string_start[c])
    fp_w.close()
    #如果没有我们寻找的模块，则删除此xml，有的话拷贝图片
    if a == 0:
        os.remove(ann_savepath+file)
    else:
        name_img = img_filepath + os.path.splitext(file)[0] + ".jpg"
        shutil.copy(name_img, img_savepath)
    fp.close()

2、修改和删除相应类别ID以及标注信息

在实际应用中，数据集无需划分子类，如原数据集中含有货船、邮轮、客船等船的子类;但是项目中只需要检测到船，并不需要划分子类，这就需要我们对将数据集中的类别进行和并重构
数据集中含有的与项目无关的类别也可以删除

import os
import random
import numpy as np
from numpy import *
 
txt_file_path = '/mnt/dir1/database/VisDrone2019/VisDrone2019-DET-val/labels'  # 原始的标签路径
save_file_path = '/mnt/dir1/database/VisDrone2019/VisDrone2019-DET-val/labels1'  # 修改后的标签路径
 
labels_name = os.listdir(txt_file_path)  # 获得每一个标签名字的列表 / os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表
num = len(labels_name)  # 获取列表长度
list = range(num)  # 创建从0到num的整数列表  list = range(0, num)
files = os.listdir(save_file_path)
 
for i in list:  # 遍历每一个文件
    name = labels_name[i]  # 获取每一个文件的文件名
    read_file = open(txt_file_path + "/" + name, 'r')  # 读取txt_file_path/labels路径中的文件，r表示以只读方式打开文件
    fline = read_file.readlines()  # 读取txt文件中每一行 / readlines()表示读取整行 / fline是列表类型，fline列表里的元素是str类型
    save_txt = open(save_file_path + "/" + name, 'w+')  # 读取save_file_path/labels路径中的文件. w+表示打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
 
    for j in fline:  # 遍历txt文件中每一行
        list1 = j.split()
        # print(list1)
 
        # 删除类别
        if list1[0] != '2':  # 删除类别2
            if list1[0] != '6':  # 删除类别6
                if list1[0] != '7':  # 删除类别7
                    if list1[0] != '9':  # 删除类别9
                    list2 = list1
                    #print(list2)
 
                    # 修改类别
                    if list2[0] == '1':
                        list2[0] = '0'  # 将类别1改成类别0
                    elif list2[0] == '3':
                        list2[0] = '1'  # 将类别3改成类别1
                    elif list2[0] == '4':
                        list2[0] = '1'  # 将类别4改成类别1
                    elif list2[0] == '5':
                        list2[0] = '1'  # 将类别5改成类别1
                    elif list2[0] == '8':
                        list2[0] = '1'  # 将类别8改成类别1
 
                    b = " ".join(list2)   # 将列表转换成字符串类型，且用空格分割
                    save_txt.write(b)  # 写入新的文件中
                    save_txt.write('\n')  # 换行

3、VOC数据集转YOLO

import xml.etree.ElementTree as ET
import pickle
import os
from os import listdir, getcwd
from os.path import join
 
 
def convert(size, box):
    x_center = (box[0] + box[1]) / 2.0
    y_center = (box[2] + box[3]) / 2.0
    x = x_center / size[0]
    y = y_center / size[1]
    w = (box[1] - box[0]) / size[0]
    h = (box[3] - box[2]) / size[1]
    return (x, y, w, h)
 
 
def convert_annotation(xml_files_path, save_txt_files_path, classes):
    xml_files = os.listdir(xml_files_path)
    #print(xml_files)
    for xml_name in xml_files:
        print(xml_name)
        xml_file = os.path.join(xml_files_path, xml_name)
        out_txt_path = os.path.join(save_txt_files_path, xml_name.split('.')[0] + '.txt')
        #
        folder = os.path.exists(save_txt_files_path)
        if not folder: #判断是否存在文件夹如果不存在则创建为文件夹
            os.makedirs(save_txt_files_path) #makedirs 创建文件时如果路径不存在会创建这个路径#
        #
        out_txt_f = open(out_txt_path, 'w', encoding="utf-8")
        tree = ET.parse(xml_file)
        root = tree.getroot()
        size = root.find('size')
        w = int(size.find('width').text)
        h = int(size.find('height').text)
 
        for obj in root.iter('object'):
            difficult = obj.find('difficult').text
            cls = obj.find('name').text
            if cls not in classes or int(difficult) == 1:
                continue
            cls_id = classes.index(cls)
            xmlbox = obj.find('bndbox')
            b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text),
                 float(xmlbox.find('ymax').text))
            # b=(xmin, xmax, ymin, ymax)
            print(w, h, b)
            bb = convert((w, h), b)
            out_txt_f.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
 
 
if __name__ == "__main__":
    # 需要转换的类别，需要一一对应
    classes1 = ['aeroplane', 'boat', 'bus', 'car', 'person']
    # 2、voc格式的xml标签文件路径
    xml_files1 = r'VOCdevkit/VOC2012/Annotations_ssd/'
    # 3、转化为yolo格式的txt标签文件存储路径
    save_txt_files1 = r'VOCdevkit/VOC2012/labels_ssd/'
 
    convert_annotation(xml_files1, save_txt_files1, classes1)