xml与python文件常用转换，读取图像

待我称王封你为后i 2023-03-01 10:56 8阅读 0赞

### 文章目录 ###

*  一、Python批量修改图片文件名和xml文件信息
 *  二、python获取图像名称保存成一个txt文件
 *  三、xml格式的label转换为yolo-darknet版的label
 *  四、使用python将voc类型标注xml文件对图片进行目标还原（显示图像和标注框）
 *  五、利用Python读取XML文件批量生成标注图像（给图像批量画框并保存）（同四）
 *  六、python opencv按照文件顺序读取图像
 *  七、python根据xml，中心裁剪图像到640像素或者抠框
 *  八、根据xml的分类，在原图画框并批量保存
 *  九、判断xml中标签是否为空，并移动空xml和空图片到指定路径
 *  十、删除xml中指定标签
 *  十一、如何批量把照片名称导入excel
 *  十二、删除xmin>xmax坐标的xml文件和对应的image
 *  十三、Python 根据txt中图片的名字批量提取对应的图片并保存到另一个文件夹（从一堆图像里复制出我们要的图像文件）
 *  十四、根据文件名保存对应的xml文件（从一堆xml里面移动出我们要的xml）
 *  十五、滑动窗口式的裁剪图片与标注框(图像裁剪,xml同步对应保存)
 *  十六、python将图像批量复制到另外一个文件夹
 *  十七、根据xml获取其文件名导出txt

# 一、Python批量修改图片文件名和xml文件信息 #

# coding:utf-8
    from PIL import Image
    import os.path
    import glob
    import xml.etree.ElementTree as ET
    import xml.dom.minidom
    
    i = 0
    xmldir = r"D:\outputs"
    imgsdir = r"D:\images"
    
    for xmlfile in os.listdir(xmldir):
        xmlname = os.path.splitext(xmlfile)[0]
        for pngfile in os.listdir(imgsdir):
            pngname = os.path.splitext(pngfile)[0]
            if pngname == xmlname:
                # 修改图片文件名
                # 图片文件名修改前后的路径
                olddir = os.path.join(os.path.abspath(imgsdir), pngname + ".jpg")
                newdir = os.path.join(os.path.abspath(imgsdir), str(i) + ".jpg")
                os.rename(olddir, newdir)
                print(xmlfile, '----->', str(i) + '.png')
                # 修改filename结点属性
                # 读取xml文件
                dom = xml.dom.minidom.parse(os.path.join(xmldir, xmlfile))
                root = dom.documentElement
    
                # 获取标签对filename之间的值并赋予新值i
                root.getElementsByTagName('filename')[0].firstChild.data = str(i) + '.png'
    
                # 将修改后的xml文件保存
                # xml文件修改前后的路径
                old_xmldir = os.path.join(xmldir, xmlfile)
                new_xmldir = os.path.join(xmldir, str(i) + '.xml')
                # 打开并写入
                with open(old_xmldir, 'w') as fh:
                    dom.writexml(fh)
                os.rename(old_xmldir, new_xmldir)
                i += 1
    print('total number is ', i)

效果：  
![在这里插入图片描述][20200724163605347.png]![在这里插入图片描述][20200724163620141.png]

# 二、python获取图像名称保存成一个txt文件 #

# -*- coding:utf-8 -*-
    import sys
    sys.path.append('D:\\Program files\\Anaconda\\libs')
    import os #os：操作系统相关的信息模块
    import random #导入随机函数
    #存放原始图片地址
    data_base_dir = "D:\images"
    file_list = [] #建立列表，用于保存图片信息
    #读取图片文件，并将图片地址、图片名和标签写到txt文件中
    write_file_name = 'image.txt'
    write_file = open(write_file_name, "w") #以只写方式打开write_file_name文件
    for file in os.listdir(data_base_dir): #file为current_dir当前目录下图片名
        if file.endswith(".jpg"): #如果file以jpg结尾
            write_name = file #图片路径 + 图片名 + 标签
            file_list.append(write_name) #将write_name添加到file_list列表最后
        sorted(file_list) #将列表中所有元素随机排列
        number_of_lines = len(file_list) #列表中元素个数
        #将图片信息写入txt文件中，逐行写入
    for current_line in range(number_of_lines):
        write_file.write(file_list[current_line][:-4] + '\n')#关闭文件

效果：  
![在这里插入图片描述][20200724163936759.png]

# 三、xml格式的label转换为yolo-darknet版的label #

# 坐标xml转txt
    import os
    import xml.etree.ElementTree as ET
    
    classes = ["play cards"]  # 输入名称，必须与xml标注名称一致
    
    def convert(size, box):
        print(size, box)
        dw = 1. / size[0]
        dh = 1. / size[1]
        x = (box[0] + box[1]) / 2.0
        y = (box[2] + box[3]) / 2.0
        w = box[1] - box[0]
        h = box[3] - box[2]
        x = x * dw
        w = w * dw
        y = y * dh
        h = h * dh
        return (x, y, w, h)
    
    
    def convert_annotation(image_id):
        print(image_id)
        in_file = open(r'./data/Annotations/%s.xml' % (image_id), 'rb')  # 读取xml文件路径
    
        out_file = open('./data/labels/%s.txt' % (image_id), 'w')  # 需要保存的txt格式文件路径
        tree = ET.parse(in_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'):
            cls = obj.find('name').text
            if cls not in classes:  # 检索xml中的名称
                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))
            bb = convert((w, h), b)
            out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
    
    
    image_ids_train = open('./ImageXML.txt').read().strip().split()  # 读取xml文件名索引
    
    for image_id in image_ids_train:
        print(image_id)
        convert_annotation(image_id)

# 四、使用python将voc类型标注xml文件对图片进行目标还原（显示图像和标注框） #

#!/usr/bin/python
    # -*- coding: UTF-8 -*-
    # get annotation object bndbox location
    import os
    import cv2
    
    try:
        import xml.etree.cElementTree as ET  # 解析xml的c语言版的模块
    except ImportError:
        import xml.etree.ElementTree as ET
    
    ##get object annotation bndbox loc start
    def GetAnnotBoxLoc(AnotPath):  # AnotPath VOC标注文件路径
        tree = ET.ElementTree(file=AnotPath)  # 打开文件，解析成一棵树型结构
        root = tree.getroot()  # 获取树型结构的根
        ObjectSet = root.findall('object')  # 找到文件中所有含有object关键字的地方，这些地方含有标注目标
        ObjBndBoxSet = {
        }  # 以目标类别为关键字，目标框为值组成的字典结构
        for Object in ObjectSet:
        	# code有可能是name，这个要根据xml文件内容修改
            ObjName = Object.find('code').text
            BndBox = Object.find('bndbox')
            x1 = int(BndBox.find('xmin').text)  # -1 #-1是因为程序是按0作为起始位置的
            y1 = int(BndBox.find('ymin').text)  # -1
            x2 = int(BndBox.find('xmax').text)  # -1
            y2 = int(BndBox.find('ymax').text)  # -1
            BndBoxLoc = [x1, y1, x2, y2]
            if ObjName in ObjBndBoxSet:
                ObjBndBoxSet[ObjName].append(BndBoxLoc)  # 如果字典结构中含有这个类别了，那么这个目标框要追加到其值的末尾
            else:
                ObjBndBoxSet[ObjName] = [BndBoxLoc]  # 如果字典结构中没有这个类别，那么这个目标框就直接赋值给其值吧
        return ObjBndBoxSet
    
    ##get object annotation bndbox loc end
    
    def display(objBox, pic):
        img = cv2.imread(pic)
    
        for key in objBox.keys():
            for i in range(len(objBox[key])):
                cv2.rectangle(img, (objBox[key][i][0], objBox[key][i][1]), (objBox[key][i][2], objBox[key][i][3]),
                              (0, 0, 255), 2)
                cv2.putText(img, key, (objBox[key][i][0], objBox[key][i][1]), cv2.FONT_HERSHEY_COMPLEX, 1, (255, 0, 0), 1)
        cv2.namedWindow('img', cv2.WINDOW_NORMAL)#opencv显示图像一部分，这个可以显示全部
        cv2.imshow('img', img)
        cv2.imwrite('display.jpg', img)
        cv2.waitKey(0)
    
    
    if __name__ == '__main__':
        pic = r"C:\Desktop\0.jpg"# 图片路径
        ObjBndBoxSet = GetAnnotBoxLoc(r"E:\xx\xml\2.xml")# xml路径
        print(ObjBndBoxSet)
        display(ObjBndBoxSet, pic)

# 五、利用Python读取XML文件批量生成标注图像（给图像批量画框并保存）（同四） #

import cv2
    import numpy as np
    
    import xml.dom.minidom
    import os
    import argparse
    
    
    def main():
        # JPG文件的地址
        img_path = './imgs/'
        # XML文件的地址
        anno_path = './xmls/'
        # 存结果的文件夹
        cut_path = './outs/'
        # 获取文件夹中的文件
        imagelist = os.listdir(img_path)
    
        for image in imagelist:
            image_pre, ext = os.path.splitext(image)
            img_file = img_path + image
            # 读取图片
            img = cv2.imread(img_file)
            xml_file = anno_path + image_pre + '.xml'
            # 打开xml文档
            DOMTree = xml.dom.minidom.parse(xml_file)
            # 得到文档元素对象
            collection = DOMTree.documentElement
            # 得到标签名为object的信息
            objects = collection.getElementsByTagName("object")
    
            for object in objects:
                # print("start")
                # 每个object中得到子标签名为name的信息
                namelist = object.getElementsByTagName('code')
                # 通过此语句得到具体的某个name的值
                objectname = namelist[0].childNodes[0].data
                bndbox = object.getElementsByTagName('bndbox')[0]
                xmin = bndbox.getElementsByTagName('xmin')[0]
                xmin_data = xmin.childNodes[0].data
                ymin = bndbox.getElementsByTagName('ymin')[0]
                ymin_data = ymin.childNodes[0].data
                xmax = bndbox.getElementsByTagName('xmax')[0]
                xmax_data = xmax.childNodes[0].data
                ymax = bndbox.getElementsByTagName('ymax')[0]
                ymax_data = ymax.childNodes[0].data
                xmin = int(xmin_data)
                xmax = int(xmax_data)
                ymin = int(ymin_data)
                ymax = int(ymax_data)
                # img_cut = img[ymin:ymax, xmin:xmax, :]  # 截取框住的目标
                # cv2.imwrite(cut_path + 'cut_img_{}.jpg'.format(image_pre), img)
                cv2.rectangle(img, (xmin, ymin), (xmax, ymax), (0, 255, 0), thickness=2)  # 生成原始值
                cv2.putText(img, objectname, (xmin, ymin), cv2.FONT_HERSHEY_COMPLEX, 0.7, (0, 255, 0), thickness=2)
                cv2.imwrite(cut_path + '{}.jpg'.format(image_pre), img)
    
    
    if __name__ == '__main__':
        main()

# 六、python opencv按照文件顺序读取图像 #

"""利用opencv读取并显示一个目录下的全部图片"""
    import os
    import cv2
     
     
    path = '/home/toybrick/hideonbush/RKNN_yolov3/pics/'
     
    # 读取path文件夹下所有文件的名字
     
    imagelist = os.listdir(path)
    imagelist.sort(key=lambda x: int(x[:x.index(".")]))
    print(imagelist)
    # 输出文件列表
    # print(imagelist)
     
    for imgname in imagelist:
     
        if(imgname.endswith(".jpg")):
     
            image = cv2.imread(path+imgname)
     
            cv2.imshow("picture",image)
     
            # 每张图片的停留时间
            k = cv2.waitKey(10)
     
            # 通过esc键终止程序
            if k == 27:
     
                break
     
    cv2.destroyAllWindows()

# 七、python根据xml，中心裁剪图像到640像素或者抠框 #

from __future__ import division
    
    import os
    
    from PIL import Image,ImageFile
    
    import xml.dom.minidom
    
    import numpy as np
    ImageFile.LOAD_TRUNCATED_IMAGES = True
    
    ImgPath = './Q/'
    
    AnnoPath = './xml/'
    
    ProcessedPath = './640/'
    
    imagelist = os.listdir(ImgPath)
    
    for image in imagelist:
    
        image_pre, ext = os.path.splitext(image)
    
        imgfile = ImgPath + image
    
        print(imgfile)
    
        if not os.path.exists(AnnoPath + image_pre + '.xml'): continue
    
        xmlfile = AnnoPath + image_pre + '.xml'
    
        DomTree = xml.dom.minidom.parse(xmlfile)
    
        annotation = DomTree.documentElement
    
        filenamelist = annotation.getElementsByTagName('filename')  # [<DOM Element: filename at 0x381f788>]
    
        # filename = filenamelist[0].childNodes[0].data
    
        objectlist = annotation.getElementsByTagName('object')
    
        i = 1
    
        for objects in objectlist:
    
            namelist = objects.getElementsByTagName('code')
    
            objectname = namelist[0].childNodes[0].data
    
            savepath = ProcessedPath + objectname
    
            if not os.path.exists(savepath):
                os.makedirs(savepath)
    
            bndbox = objects.getElementsByTagName('bndbox')
    
            cropboxes = []
    
            for box in bndbox:
    
                x1_list = box.getElementsByTagName('xmin')
    
                x1 = int(x1_list[0].childNodes[0].data)
    
                y1_list = box.getElementsByTagName('ymin')
    
                y1 = int(y1_list[0].childNodes[0].data)
    
                x2_list = box.getElementsByTagName('xmax')
    
                x2 = int(x2_list[0].childNodes[0].data)
    
                y2_list = box.getElementsByTagName('ymax')
    
                y2 = int(y2_list[0].childNodes[0].data)
    
                w = x2 - x1
    
                h = y2 - y1
    
                #obj = np.array([x1, y1, x2, y2])# 抠框
                obj = np.array([x1-(640-x2+x1)/2, y1-(640-x2+x1)/2, x1-(640-x2+x1)/2+640, y1-(640-x2+x1)/2+640])
                shift = np.array([[1, 1, 1, 1]])
    
                XYmatrix = np.tile(obj, (1, 1))
    
                cropboxes = XYmatrix * shift
                print(cropboxes)
                img = Image.open(imgfile)
    
                for cropbox in cropboxes:
                    cropedimg = img.crop(cropbox)
    
                    cropedimg.save(savepath + '/' + image_pre + '_' + str(i) + '.jpg')
    
                    i += 1

# 八、根据xml的分类，在原图画框并批量保存 #

from __future__ import division
    import os
    from PIL import Image
    import xml.dom.minidom
    import numpy as np
    from PIL import ImageFile
    ImageFile.LOAD_TRUNCATED_IMAGES = True
    import cv2
    
    ImgPath = './imgs/'
    AnnoPath = './xmls/'
    ProcessedPath = './iii/'
    if not os.path.exists(ProcessedPath):
        os.makedirs(ProcessedPath)
    imagelist = os.listdir(ImgPath)
    for image in imagelist:
        image_pre, ext = os.path.splitext(image)
        imgfile = ImgPath + image
        print(imgfile)
        if not os.path.exists(AnnoPath + image_pre + '.xml'): continue
        xmlfile = AnnoPath + image_pre + '.xml'
        DomTree = xml.dom.minidom.parse(xmlfile)
        annotation = DomTree.documentElement
        objectlist = annotation.getElementsByTagName('object')
        img = cv2.imread(imgfile)
        for objects in objectlist:
            namelist = objects.getElementsByTagName('code')
            # 通过此语句得到具体的某个name的值
            objectname = namelist[0].childNodes[0].data
            bndbox = objects.getElementsByTagName('bndbox')[0]
            xmin = bndbox.getElementsByTagName('xmin')[0]
            xmin_data = xmin.childNodes[0].data
            ymin = bndbox.getElementsByTagName('ymin')[0]
            ymin_data = ymin.childNodes[0].data
            xmax = bndbox.getElementsByTagName('xmax')[0]
            xmax_data = xmax.childNodes[0].data
            ymax = bndbox.getElementsByTagName('ymax')[0]
            ymax_data = ymax.childNodes[0].data
            xmin = int(xmin_data)
            xmax = int(xmax_data)
            ymin = int(ymin_data)
            ymax = int(ymax_data)
            savepath = ProcessedPath + objectname
            if not os.path.exists(savepath):
                os.makedirs(savepath)
            cv2.rectangle(img, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (0, 255, 0),
                          thickness=2)  # 生成原始值
            cv2.putText(img, objectname,(int(xmin), int(ymin)), cv2.FONT_HERSHEY_COMPLEX, 0.7, (0, 255, 0), thickness=2)
            cv2.imwrite(savepath + '/' + image_pre + '.jpg',img)

# 九、判断xml中标签是否为空，并移动空xml和空图片到指定路径 #

#!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    # 移动标签为空的xml，并同步移动相应图片
    import os
    import xml.etree.ElementTree as ET
    import shutil
    
    origin_ann_dir = './data/Annotations/'  # 设置原始标签路径为 Annos
    new_ann_dir = './newxmls/'  # 设置新标签路径 Annotations
    origin_pic_dir = './data/images/'
    new_pic_dir = './newimgs/'
    if not os.path.exists(new_ann_dir):
        os.mkdir(new_ann_dir)
    if not os.path.exists(new_pic_dir):
        os.mkdir(new_pic_dir)
    k = 0
    p = 0
    q = 0
    for dirpaths, dirnames, filenames in os.walk(origin_ann_dir):  # os.walk游走遍历目录名
        for filename in filenames:
            print("process...")
            k = k + 1
            print(k)
            if os.path.isfile(r'%s%s' % (origin_ann_dir, filename)):  # 获取原始xml文件绝对路径，isfile()检测是否为文件 isdir检测是否为目录
                origin_ann_path = os.path.join(r'%s%s' % (origin_ann_dir, filename))  # 如果是，获取绝对路径（重复代码）
                new_ann_path = os.path.join(r'%s%s' % (new_ann_dir, filename))
                tree = ET.parse(origin_ann_path)  # ET是一个xml文件解析库，ET.parse（）打开xml文件。parse--"解析"
                root = tree.getroot()  # 获取根节点
                if len(root.findall('object')):
                    p = p + 1
                else:
                    print(filename)
                    old_xml = origin_ann_dir + filename
                    new_xml = new_ann_dir + filename
                    old_pic = origin_pic_dir + filename.replace("xml", "jpg")
                    new_pic = new_pic_dir + filename.replace("xml", "jpg")
                    q = q + 1
                    shutil.move(old_pic, new_pic)
                    shutil.move(old_xml, new_xml)
    print("ok, ", p)
    print("empty, ", q)

# 十、删除xml中指定标签 #

import os
    import xml.etree.ElementTree as ET
    import tqdm
    
    
    def del_delete_eq_1(xml_path):
        # 从xml文件中读取，使用getroot()获取根节点，得到的是一个Element对象
        tree = ET.parse(xml_path)
        root = tree.getroot()
    
        for object in root.findall('object'):
            deleted = str(object.find('name').text)
            print(object)
            if (deleted in ['花盆', '骨头']):
                root.remove(object)
    
            tree.write(xml_path)
    
    def main():
        root_dir = "./data/Annotations"
        xml_path_list = [os.path.join(root_dir, x) for x in os.listdir(root_dir)]
    
        # 使用tqdm显示进程
        for xml in tqdm.tqdm(xml_path_list):
            del_delete_eq_1(xml)
    
    if __name__ == '__main__':
        main()

# 十一、如何批量把照片名称导入excel #

[https://jingyan.baidu.com/article/455a9950e766e1e0662778a7.html][https_jingyan.baidu.com_article_455a9950e766e1e0662778a7.html]

# 十二、删除xmin>xmax坐标的xml文件和对应的image #

修改图像文件夹名称为IMAGES，新建文件夹ERROR

import xml.etree.ElementTree as xml_tree
    import os
    import shutil
    
    def check_box(path):
        files = os.listdir(path)
        i = 0
        for anna_file in files:
            tree = xml_tree.parse(path + "/" + anna_file)
            root = tree.getroot()
            for obj in root.findall('object'):
    
                bbox = obj.find('bndbox')
                if (float(bbox.find('ymin').text) >= float(bbox.find('ymax').text)) or (
                        float(bbox.find('xmin').text) >= float(bbox.find('xmax').text)):
                    print(anna_file)
                    i += 1
                    try:
                        shutil.move(path + "/" + anna_file, "./error2/" + anna_file)
                        shutil.move("./IMAGES/" + anna_file.split(".")[0] + ".jpg",
                                    "./ERROR/" + anna_file.split(".")[0] + ".jpg")
                    except:
                        pass
    
        print(i)
    
    
    if __name__ == "__main__":
        check_box("./xml")

# 十三、Python 根据txt中图片的名字批量提取对应的图片并保存到另一个文件夹（从一堆图像里复制出我们要的图像文件） #

先获得需要转换的图像名称的txt文件

# -*- coding:utf-8 -*-
    import sys
    sys.path.append('D:\\Program files\\Anaconda\\libs')
    import os #os：操作系统相关的信息模块
    import random #导入随机函数
    #存放原始图片地址
    data_base_dir = "./imgs"
    file_list = [] #建立列表，用于保存图片信息
    #读取图片文件，并将图片地址、图片名和标签写到txt文件中
    write_file_name = 'image.txt'
    write_file = open(write_file_name, "w") #以只写方式打开write_file_name文件
    for file in os.listdir(data_base_dir): #file为current_dir当前目录下图片名
        if file.endswith(".jpg"): #如果file以jpg结尾
            write_name = file #图片路径 + 图片名 + 标签
            file_list.append(write_name) #将write_name添加到file_list列表最后
        sorted(file_list) #将列表中所有元素随机排列
        number_of_lines = len(file_list) #列表中元素个数
        #将图片信息写入txt文件中，逐行写入
    for current_line in range(number_of_lines):
        write_file.write(file_list[current_line][:-4] + '\n')#关闭文件

根据txt文件保存需要的图像到新文件夹

# -*- coding: UTF-8 -*-
    #!/usr/bin/env python
    import sys
    import re
    from PIL import Image
    import os
    
    if not os.path.exists("./outimgs"):
        os.makedirs("./outimgs")
    # sys.path.append('E:\\CODE')
    data = []
    for line in open("./image.txt", "r"):  # 设置文件对象并读取每一行文件
        data.append(line)
    for a in data:
      im = Image.open('./imgs/{}'.format(a[:-1])+".jpg")#打开改路径下的line3记录的的文件名
      im.save('./outimgs/{}'.format(a[:-1])+".jpg") #把文件夹中指定的文件名称的图片另存到该路径下（+".jpg"看自己的txt文件内容后缀是否包含）
      im.close()

# 十四、根据文件名保存对应的xml文件（从一堆xml里面移动出我们要的xml） #

先获得需要转换的xml名称的txt文件

# -*- coding:utf-8 -*-
    import sys
    sys.path.append('D:\\Program files\\Anaconda\\libs')
    import os #os：操作系统相关的信息模块
    import random #导入随机函数
    #存放原始图片地址
    data_base_dir = r"F:\zy\2haotu"
    file_list = [] #建立列表，用于保存图片信息
    #读取图片文件，并将图片地址、图片名和标签写到txt文件中
    write_file_name = 'image.txt'
    write_file = open(write_file_name, "w") #以只写方式打开write_file_name文件
    for file in os.listdir(data_base_dir): #file为current_dir当前目录下图片名
        if file.endswith(".jpg"): #如果file以jpg结尾
            write_name = file #图片路径 + 图片名 + 标签
            file_list.append(write_name) #将write_name添加到file_list列表最后
        sorted(file_list) #将列表中所有元素随机排列
        number_of_lines = len(file_list) #列表中元素个数
        #将图片信息写入txt文件中，逐行写入
    for current_line in range(number_of_lines):
        write_file.write(file_list[current_line][:-4] +'\n')#关闭文件

再保存对应的xml文件到新文件夹

import os
    import shutil
    
    
    if __name__ == '__main__':
        f = open("./image.txt","r")   #存放有XML文件名字的txt
    
        line = f.readline()
        line = line[:-1]
    	if not os.path.exists("./out"):
            os.makedirs("./out")
        while line:
            line = f.readline()
            line = line.strip('\n')
            print(line)
            # path = os.getcwd()
            new_path = r"F:/zy/6yuexmls/"+line+".xml"   #路径为保存XML文件的文件夹（位置为我们所有的xml文件，从中移动到out文件夹下）
            print(new_path)
            try:
                shutil.move(new_path, './out')   #提取后保存的位置
            except:
                print("Not find error.")
            # print(path)
        f.close()

# 十五、滑动窗口式的裁剪图片与标注框(图像裁剪,xml同步对应保存) #

这里是实现分辨率为w\_h裁剪成多张a\_a大小的图片（a<=w且a<=h），以大小为a/2的步长滑动，裁剪同时修改标注框。

xml\_parse.py

import xml.dom.minidom as xmldom
    import os.path
    
    
    def voc_xml_parse(xml_path):
        object_list = []
        domobj = xmldom.parse(xml_path)
        elementobj = domobj.documentElement
        folderobj = elementobj.getElementsByTagName("folder")[0]
        filenameobj = elementobj.getElementsByTagName("filename")[0]
        # sourceobj = elementobj.getElementsByTagName("source")[0]
        # ownerobj = elementobj.getElementsByTagName("owner")[0]
        sizeobj = elementobj.getElementsByTagName("size")[0]
        # segmentedobj = elementobj.getElementsByTagName("segmented")[0]
        head = {
        'folder': folderobj, 'filename': filenameobj, 'size': sizeobj,}
        object_list = elementobj.getElementsByTagName("object")
        return head, object_list
    
    
    def voc_xml_modify(modify_xml_path, head, object_list):
        dom = xmldom.Document()
        root = dom.createElement('annotation')
        dom.appendChild(root)
        for obj in head.values():
            root.appendChild(obj)
        for obj in object_list:
            root.appendChild((obj))
        with open(modify_xml_path, 'w', encoding='utf-8') as f:
            dom.writexml(f, addindent='\t', newl='\n', encoding='utf-8')
        return

export.py

# coding:utf-8
    import cv2
    import os
    import codecs
    import xml_parse
    import xml.dom.minidom as xmldom
    import xml.etree.ElementTree as ET
    import numpy as np
    from PIL import Image
    from tqdm import tqdm
    import sys
    
    sys.setrecursionlimit(10000)
    
    
    def load_image_into_numpy_array(image):
        (im_width, im_height) = image.size
        return np.array(image.getdata()).reshape(
            (im_height, im_width, 3)).astype(np.uint16)
    
    
    def crop_xml_modify(head, objectlist, hmin, wmin, new_height, new_width, origin_xml__path):
        filenameobj = head['filename']
        sizeobj = head['size']
        width = sizeobj.getElementsByTagName('width')[0]
        width.childNodes[0].data = str(new_width)
        # print(str(WIDTH))
        height = sizeobj.getElementsByTagName('height')[0]
        height.childNodes[0].data = str(new_height)
        # tree = ET.parse(origin_xml__path)
        # root = tree.getroot()
        obj = objectlist
        i = 0
        while (i < obj.length):
            # for obj in objectlist1:
            bndbox = obj[i].getElementsByTagName('bndbox')[0]
            xmin = bndbox.getElementsByTagName('xmin')[0]
            XMIN = float(xmin.childNodes[0].data)
            ymin = bndbox.getElementsByTagName('ymin')[0]
            YMIN = float(ymin.childNodes[0].data)
            xmax = bndbox.getElementsByTagName('xmax')[0]
            XMAX = float(xmax.childNodes[0].data)
            ymax = bndbox.getElementsByTagName('ymax')[0]
            YMAX = float(ymax.childNodes[0].data)
            if (XMIN >= wmin) and (XMAX <= (wmin + new_width)) and (YMIN >= hmin) and (YMAX <= (hmin + new_height)):
                xmin.childNodes[0].data = str(int(XMIN - wmin))
                xmax.childNodes[0].data = str(int(XMAX - wmin))
                ymin.childNodes[0].data = str(int(YMIN - hmin))
                ymax.childNodes[0].data = str(int(YMAX - hmin))
            else:
                obj.remove(obj[i])
                i = i - 1  # 一定要向前提一个位置 删除的话用for是会出错的 耽搁了好久。。。
                # obj = objectlist1[i-1]
            i = i + 1
        return head, obj
    
    
    def crop_dataset(imgpath, output_shape, annotation, cropAnno, cropImg, stride):
        origin_image = cv2.imread(imgpath)
        # image = Image.open(imgpath)
        # image_np = load_image_into_numpy_array(image)
        # origin_image = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
        height, width = origin_image.shape[:2]
        # print(height)
        # print(width)
        domobj = xmldom.parse(annotation)
        elementobj = domobj.documentElement
        name = elementobj.getElementsByTagName("name")
        size = len(name)
        # tree = ET.parse(origin_xml__path)
        # root = tree.getroot()
        x = 0
        newheight = output_shape
        newwidth = output_shape
        while x < width:
            y = 0
            if x + newwidth <= width:
                while y < height:
                    # 裁剪为output_shape*output_shape
                    # newheight = output_shape
                    # newwidth = output_shape
                    head, objectlist = xml_parse.voc_xml_parse(annotation)
                    if y + newheight <= height:
                        hmin = y
                        hmax = y + newheight
                        wmin = x
                        wmax = x + newwidth
                    else:
                        hmin = height - newheight
                        hmax = height
                        wmin = x
                        wmax = x + newwidth
                        y = height  # test
                    modify_head, modify_objectlist = crop_xml_modify(head, objectlist, hmin, wmin, newheight, newwidth,
                                                                     origin_xml__path)
                    cropAnno1 = cropAnno + '_' + str(wmax) + '_' + str(hmax) + '_' + str(output_shape) + '.xml'
                    xml_parse.voc_xml_modify(cropAnno1, modify_head, modify_objectlist)
                    cropImg1 = cropImg + '_' + str(wmax) + '_' + str(hmax) + '_' + str(output_shape) + '.png'
                    cv2.imwrite(cropImg1, origin_image[hmin: hmax, wmin: wmax])
                    y = y + stride
                    if y + output_shape == height:  # 第一张图就已经涵盖了height*height
                        y = height
                    # if y + newheight > height:
                    #     break
            else:
                while y < height:
                    # 裁剪为output_shape*output_shape
                    # newheight = output_shape
                    # newwidth = output_shape
                    head, objectlist = xml_parse.voc_xml_parse(annotation)
                    if y + newheight <= height:
                        hmin = y
                        hmax = y + newheight
                        wmin = width - newwidth
                        wmax = width
                    else:
                        hmin = height - newheight
                        hmax = height
                        wmin = width - newwidth
                        wmax = width
                        y = height  # test
                    modify_head, modify_objectlist = crop_xml_modify(head, objectlist, hmin, wmin, newheight, newwidth,
                                                                     origin_xml__path)
                    cropAnno1 = cropAnno + '_' + str(wmax) + '_' + str(hmax) + '_' + str(output_shape) + '.xml'
                    xml_parse.voc_xml_modify(cropAnno1, modify_head, modify_objectlist)
                    cropImg1 = cropImg + '_' + str(wmax) + '_' + str(hmax) + '_' + str(output_shape) + '.png'
                    cv2.imwrite(cropImg1, origin_image[hmin: hmax, wmin: wmax])
                    y = y + stride
                    # if y + newheight > height:
                    #     break
                x = width
            x = x + stride
            if x + output_shape == width:  # 第一张图就已经涵盖了height*height
                x = width
            # if x + newwidth > width:
            #     break
    
    
    if __name__ == '__main__':
        # output_shape 为想要裁剪成的图片尺寸
        output_shape = 1280  # 512 1024
        stride = int(output_shape / 2)
        imgpath = './myimgs/'  # 原图路径
        annotation = './myxmls/'  # 原图对应的标注xml文件路径
        cropAnno = './myoutxmls/'  # 裁剪后存储xml的路径
        cropImg = './myoutimgs/'  # 裁剪后存储图片的路径
        if not os.path.exists(cropImg):
            os.mkdir(cropImg)
        if not os.path.exists(cropAnno):
            os.mkdir(cropAnno)
    
        for each in tqdm(os.listdir(annotation)):
            # each = os.listdir(annotation)
            name = each.split('.')[0]
            origin_img_path = os.path.join(imgpath, name + '.jpg')
            origin_xml__path = os.path.join(annotation, name + '.xml')
            crop_img_path = os.path.join(cropImg, name)
            crop_xml__path = os.path.join(cropAnno, name)
            # tree = ET.parse(origin_xml__path)
            # root = tree.getroot()
            crop_dataset(origin_img_path, output_shape, origin_xml__path, crop_xml__path, crop_img_path, stride)

# 十六、python将图像批量复制到另外一个文件夹 #

ImageXML.txt示例  
![在这里插入图片描述][20210713143346841.png]

data = []
    for line in open("./ImageXML.txt", "r"):  # 设置文件对象并读取每一行文件
        data.append(line)
    for a in data:
        new_obj_name = a[:-1] + '.JPG'
        print(new_obj_name)
        shutil.copy('img'+'/'+new_obj_name,'out'+'/'+new_obj_name)

# 十七、根据xml获取其文件名导出txt #

# -*- coding:utf-8 -*-
    #import sys
    #sys.path.append('D:\\Program files\\Anaconda\\libs')
    import os #os：操作系统相关的信息模块
    import random #导入随机函数
    #存放原始图片地址
    data_base_dir = "xml"
    file_list = [] #建立列表，用于保存图片信息
    #读取图片文件，并将图片地址、图片名和标签写到txt文件中
    write_file_name = 'ImageXML.txt'
    write_file = open(write_file_name, "w") #以只写方式打开write_file_name文件
    for file in os.listdir(data_base_dir): #file为current_dir当前目录下图片名
        if file.endswith(".xml"): #如果file以jpg结尾
            write_name = file #图片路径 + 图片名 + 标签
            file_list.append(write_name) #将write_name添加到file_list列表最后
        sorted(file_list) #将列表中所有元素随机排列
        number_of_lines = len(file_list) #列表中元素个数
        #将图片信息写入txt文件中，逐行写入
    for current_line in range(number_of_lines):
        write_file.write(file_list[current_line][:-4] + '\n')#关闭文件

效果：  
![在这里插入图片描述][20210713143841618.png]

[20200724163605347.png]: https://img-blog.csdnimg.cn/20200724163605347.png
[20200724163620141.png]: /images/20230208/30e8067ff44a4e1bbd3b3b55d743030d.png
[20200724163936759.png]: /images/20230208/94646d2343a14833baf21ee9ed64cf63.png
[https_jingyan.baidu.com_article_455a9950e766e1e0662778a7.html]: https://jingyan.baidu.com/article/455a9950e766e1e0662778a7.html
[20210713143346841.png]: /images/20230208/a4a4d3f95470492a8c05ccbd31b7ee69.png
[20210713143841618.png]: /images/20230208/ddd9798cfdda4762bfc4453d68e831a6.png