• 入职算法工程师后敲的非常有趣使用的小工具

    NOTE：代码仅用来参考，没时间解释啦！

    🍉一、自动从数据库从抽取数据。

    在某台服务器中，从存放数据集的数据库自动抽取标注好的数据标签，这一步操作有什么用呢？当我们发现我们数据不均衡的时候，就如上图右边部分。我们可以从数据库中抽取缺少的数据标签进行填充。

    1. import os
    2. import shutil
    3. # from get_structs import print_file_structure
    4. import random
    5.  
    6. def print_file_structure(file_path, indent=''):
    7.     if os.path.isfile(file_path):
    8.         print(indent + '├── ' + os.path.basename(file_path))
    9.     elif os.path.isdir(file_path):
    10.         print(indent + '├── ' + os.path.basename(file_path))
    11.         for root, dirs, files in os.walk(file_path):
    12.             for name in dirs:
    13.                 print(indent + '│   ├── ' + name)
    14.             for name in files:
    15.                 print(indent + '│   └── ' + name)
    16.                 break  # Only print files in the top-level directory
    17.             break  # Only print directories in the top-level directory
    18.     else:
    19.         print('无效的文件路径')
    20.  
    21. def from_dataset_get_data_label(source_dataset_path, label):
    22.     subFiles = os.listdir(source_dataset_path)
    23.     if label not in subFiles:
    24.         print("您输入的标签名无效,不存在于test子目录中！")
    25.         return 
    26.     target_path = os.path.join(source_dataset_path, label)
    27.     label_lenght = count_jpg_files(target_path)
    28.     print("<{}>标签的数量统计为：【{}】".format(label, label_lenght))
    29.     print('------------------------------------')
    30.     all_need_img_paths = []
    31.     all_need_xml_paths = []
    32.     for file_name in os.listdir(target_path):
    33.         subPath = os.path.join(target_path, file_name)
    34.         if not os.path.isdir(subPath):
    35.             continue
    36.         for data_name in os.listdir(subPath):
    37.             if data_name.endswith('.jpg'):
    38.                 xml_file = os.path.splitext(data_name)[0] + '.xml'
    39.                 if os.path.exists(os.path.join(subPath, xml_file)):
    40.                     all_need_img_paths.append(os.path.join(subPath, data_name))
    41.                     all_need_xml_paths.append(os.path.join(subPath, xml_file))
    42.     # print(all_need_img_paths[:5])
    43.     print("统计有xml的图片数量：",len(all_need_img_paths))
    44.     print('------------------------------------')
    45.     get_num = int(input("请输入您要随机抽取的数据数量："))
    46.     print('------------------------------------')
    47.     if get_num > len(all_need_img_paths):
    48.         get_num = len(all_need_img_paths) - 1
    49.     random_indexs = random.sample(range(len(all_need_img_paths)), get_num)
    50.     print("请注意！所有文件都会复制到工作目录，请慎重选择工作目录。")
    51.     print('------------------------------------')
    52.     opt = input("请选择您的移动方式：[cp/mv]")
    53.     print('------------------------------------')
    54.     while opt not in ['cp', 'mv']:
    55.         opt = input("[ERROR]请选择您的移动方式：[cp/mv]")
    56.         print('------------------------------------')
    57.     if opt == 'cp':
    58.         for inx in random_indexs:
    59.             wd = os.getcwd()
    60.             if not os.path.exists(wd + '/' + 'images'):
    61.                 os.makedirs(wd + '/' + 'images')
    62.             if not os.path.exists(wd + '/' + 'Annotations'):
    63.                 os.makedirs(wd + '/' + 'Annotations')
    64.  
    65.             img_path = all_need_img_paths[inx]
    66.             shutil.copyfile(img_path, wd + '/' + 'images/' + img_path.split('/')[-1])
    67.             xml_path = all_need_xml_paths[inx]
    68.             shutil.copyfile(xml_path, wd + '/' + 'Annotations/' + xml_path.split('/')[-1])
    69.     elif opt == 'mv':
    70.         pass
    71.  
    72.     print("在上列操作中您选择了{}标签，从中抽取了{}数据量，并且使用{}方式放到了{}工作目录下。".format(label, get_num, opt, wd))
    73.     print('------------------------------------')
    74. def count_jpg_files(path):
    75.     count = 0
    76.     for root, dirs, files in os.walk(path):
    77.         for file in files:
    78.             if file.endswith('.jpg'):
    79.                 xml_file = os.path.splitext(file)[0] + '.xml'
    80.                 if os.path.exists(os.path.join(root, xml_file)):
    81.                     count += 1
    82.     return count
    83.  
    84. if __name__ == "__main__":
    85.     source_dataset_path = '/data/personal/chz/find_allimgs_label/test'
    86.     use_labels = ["zsd_m","zsd_l","fhz_h","fhz_f","kk_f","kk_h","fhz_bs", "fhz_ycn","fhz_wcn","fhz_red_h", "fhz_green_f", "fhz_m", "bs_ur", "bs_ul", "bs_up", "bs_down", "fhz_ztyc", "bs_right", "bs_left", "bs_dl", "bs_dr", "kgg_ybh", "kgg_ybf", "yljdq_flow", "yljdq_stop"]
    87.     print_file_structure(source_dataset_path, "")
    88.     print('------------------------------------')
    89.     label = input("请您根据上列中的test菜单，选取您想要的标签：")
    90.     print('------------------------------------')
    91.     from_dataset_get_data_label(source_dataset_path, label)

    🍉二、 自动从指定minIo拉取图片到另外一台minIO

    1. import minio
    2. import pymysql
    3. import openpyxl
    4. import os 
    5.  
    6. def get_data_from_mysql():
    7.     # 连接数据库-
    8.     conn = pymysql.connect(host="10.168.1.94", user="", passwd="", db="RemotePatrolDB", port=, charset="utf8")
    9.     cur = conn.cursor()  # 创建游标对象
    10.  
    11.     # 查询表中数据
    12.     cur.execute("SELECT * FROM CorrectPoint;")
    13.     df = cur.fetchall()  # 获取所有数据
    14.     imageUrls = []
    15.     for data in df:
    16.         imageUrls.append(data[15])
    17.         # print(data[15])
    18.     cur.close()
    19.     conn.close()
    20.     return imageUrls
    21.  
    22. def save_for_excel(df):
    23.     wb = openpyxl.Workbook()
    24.     ws = wb.active
    25.     for row in df:
    26.         ws.append(row)
    27.     wb.save("文件名.xlsx")
    28.  
    29.  
    30. # 从minio上面拉取图片
    31. def load_data_minio(bucket: str, imageUrls):
    32.     minio_conf = {
    33.     'endpoint': '10.168.1.96:9000',
    34.     'access_key': '',
    35.     'secret_key': '',
    36.     'secure': False
    37. }
    38.     client = minio.Minio(**minio_conf)
    39.     if not client.bucket_exists(bucket):
    40.         return None
    41.     
    42.     root_path = os.path.join("imageUrlFromminIO") 
    43.     for imageUrl in imageUrls:
    44.         imageUrl = imageUrl.split('/')[-1]
    45.         data = client.get_object(bucket, imageUrl)
    46.         save_path = os.path.join(root_path, imageUrl)  
    47.         with open(save_path, 'wb') as file_data:
    48.             for d in data.stream(32 * 1024):
    49.                 file_data.write(d)
    50.     return data.data
    51.  
    52. # 上传图片到minio    
    53. def up_data_minio(bucket: str, image_Urls_path='imageUrlFromminIO'):
    54.     # TODO：minio_conf唯一要修改的地方！
    55.     minio_conf = {
    56.     'endpoint': '192.168.120.188', 
    57.     'access_key': '',
    58.     'secret_key': '',
    59.     'secure': False
    60. }
    61.     for im_name in os.listdir(image_Urls_path):
    62.         client = minio.Minio(**minio_conf)
    63.         '''
    64.         client.fput_object('mybucket', 'myobject.jpg', '/path/to/myobject.jpg', content_type='image/jpeg')
    65.         '''
    66.         client.fput_object(bucket_name=bucket, object_name=im_name,
    67.                         file_path=os.path.join(image_Urls_path, im_name),
    68.                         content_type='image/jpeg'
    69.                         )        
    70.  
    71. def download():
    72.     # NOTE：Step:1 拉取数据库信息
    73.     imageUrls = get_data_from_mysql()
    74.     # NOTE：Step:2 把图片从96的minio上面拉下来
    75.     print(type(load_data_minio("test", imageUrls)))
    76.  
    77. def upload():
    78.     # NOTE：Step:3 把拉下来的图片传上去给XXX服务器的minio
    79.     up_data_minio("test", image_Urls_path='imageUrlFromminIO')
    80.  
    81. if __name__ == "__main__":
    82.     # 拉取使用
    83.     download()
    84.     # 上推使用
    85.     # upload()
    86.     '''
    87.     用于批量修改数据库ImagePath字段信息，替换为自己的ip。
    88.     ---
    89.     UPDATE CorrectPoint SET ImagePath=REPLACE(ImagePath, '10.168.1.96', '192.168.120.188');
    90.     '''    
    91.  
    92.     
    93.

    🍉三、目标检测画出中文框并且自动红底白字

    需要放一个文件到本地目录：

    链接：https://pan.baidu.com/s/1iEJKpqt-z_5yBJdenUABbA 
    提取码：uoox 
    --来自百度网盘超级会员V3的分享

    1. def cv2AddChineseText(self, img_ori, text, p1, box_color, textColor=(255, 255, 255), textSize=17):
    2.         if (isinstance(img_ori, np.ndarray)):  # 判断是否OpenCV图片类型
    3.             img = Image.fromarray(cv2.cvtColor(img_ori, cv2.COLOR_BGR2RGB))
    4.         # 创建一个可以在给定图像上绘图的对象
    5.         draw = ImageDraw.Draw(img)
    6.         # 字体的格式
    7.         fontStyle = ImageFont.truetype(
    8.             "simsun.ttc", textSize, encoding="utf-8")
    9.         # 绘制文本
    10.         text_width, text_height = draw.textsize(text, font=fontStyle)
    11.         position = []
    12.         outside_x = p1[0] + text_width + 3 < img.width
    13.         outside_y = p1[1] - text_height - 3 >= 0
    14.         position.append(p1[0] + 3 if outside_x else img.width - text_width)
    15.         position.append(p1[1] - text_height - 3 if outside_y else p1[1] + 3)
    16.         p2 = (position[0] + text_width, position[1] +  text_height)
    17.         image = cv2.rectangle(img_ori, position, p2, box_color, -1, cv2.LINE_AA)  # filled
    18.         img = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
    19.         draw = ImageDraw.Draw(img)
    20.         draw.text((position[0], position[1]), text, textColor, font=fontStyle)
    21.         # 转换回OpenCV格式
    22.         return cv2.cvtColor(np.asarray(img), cv2.COLOR_RGB2BGR)
    23.  
    24.     def draw_boxs(self, boxes, image):
    25.         for res in boxes:
    26.             box = [res[0], res[1], res[2]+res[0], res[3]+res[1]]
    27.             label = self.labels[res[4]]
    28.             conf = round(res[5], 4)
    29.  
    30.             box = np.array(box[:4], dtype=np.int32)  # xyxy
    31.  
    32.             line_width = int(3)
    33.             txt_color = (255, 255, 255)
    34.             box_color = (58, 56, 255)
    35.  
    36.             p1, p2 = (box[0], box[1]), (box[2], box[3])
    37.             image = cv2.rectangle(image, p1, p2, box_color, line_width)
    38.  
    39.             tf = max(line_width - 1, 1)  # font thickness
    40.             box_label = '%s: %.2f' % (self.get_desc(label), conf)
    41.             image = self.cv2AddChineseText(image, box_label, p1, box_color, txt_color)
    42.         return image

    🍉四、标注得到的xml自动转成txt

    使用labelimage标注的文件是xml的，无法用来yolo训练，所以需要使用自动转换工具把xml都转换为txt。

    请确保目录结构如下：

    1. import os
    2. import xml.etree.ElementTree as ET
    3. import cv2
    4. import random
    5. from tqdm import tqdm
    6. from multiprocessing import Pool
    7. import numpy as np
    8. import shutil
    9. '''
    10. 优化之前：
    11. 1.把函数路径改为新的数据集，先运行一次，生成txt；
    12. 2.把新的数据集Images Annotations labels都手动放入 原生数据集；
    13. 3.再把路径改回来原生数据集，再运行一次，生成txt；
    14. 问题：
    15. （1）txt不是追加模式，虽然会在第三步被覆盖掉，但重复执行没必要。
    16. （2）有很多地方类似（1）其实是运行了两次的。
    17. 优化之后：
    18. 1.把函数路径改为新的数据集，运行一次，完成！
    19. '''
    20. random.seed(0)
    21. class Tools_xml2yolo(object):
    22.     def __init__(self, 
    23.                 img_path = r"ft_220/images", 
    24.                 anno_path = r"ft_220/annotations_xml",
    25.                 label_path = r"ft_220/labels",
    26.                 themeFIle = 'ft_220',
    27.                 classes = [""],
    28.                 the_data_is_new=False
    29.         ) -> None:
    30.         self.img_path = img_path
    31.         self.anno_path = anno_path
    32.         self.label_path = label_path
    33.         self.the_data_is_new = the_data_is_new
    34.         self.classes = classes
    35.      
    36.         self.txt_path = themeFIle
    37.         if the_data_is_new:
    38.             self.ftest = open(os.path.join(self.txt_path,'test.txt'), 'a')
    39.             self.ftrain = open(os.path.join(self.txt_path,'train.txt'), 'a')
    40.         else:
    41.             self.ftest = open(os.path.join(self.txt_path,'test.txt'), 'w')
    42.             self.ftrain = open(os.path.join(self.txt_path,'train.txt'), 'w')
    43.  
    44.         train_percent = 1
    45.  
    46.         self.files = os.listdir(self.anno_path)
    47.         num = len(self.files)
    48.         # print('num image',num)
    49.         list = range(num)
    50.         tr = int(num * train_percent)
    51.         self.train_list = random.sample(list, tr)
    52.         print('len train', self.train_list)
    53.         if not os.path.exists(self.label_path):
    54.             os.makedirs(self.label_path)
    55.  
    56.     def resi(self, num):
    57.         x = round(num, 6)
    58.         x = str(abs(x))
    59.         while len(x) < 8:
    60.             x = x + str(0)
    61.         return x
    62.  
    63.     def convert(self, size, box):
    64.         dw = 1./size[0]
    65.         dh = 1./size[1]
    66.         x = (box[0] + box[1])/2.0 # x = x轴中点
    67.         y = (box[2] + box[3])/2.0 # y = y轴中点
    68.         w = box[1] - box[0] #w = width
    69.         h = box[3] - box[2] # h = height
    70.         x = self.resi(x*dw)
    71.         w = self.resi(w*dw)
    72.         y = self.resi(y*dh)
    73.         h = self.resi(h*dh)
    74.         return (x,y,w,h)
    75.  
    76.     # import glob
    77.     def process(self, name):
    78.         # found_flag = 0
    79.         img_names = ['.jpg','.JPG','.PNG','.png','.jpeg']
    80.         for j in img_names:
    81.             img_name = os.path.splitext(name)[0] + j
    82.             iter_image_path = os.path.join(self.img_path, img_name)
    83.             # print("iter image path:", iter_image_path)
    84.             if os.path.exists(iter_image_path):
    85.                 break
    86.         
    87.         xml_name = os.path.splitext(name)[0] + ".xml"
    88.         txt_name = os.path.splitext(name)[0] + ".txt"
    89.         string1 = ""
    90.         # print(name)
    91.         w,h = None, None
    92.         iter_anno_path = os.path.join(self.anno_path, xml_name)
    93.         iter_txt_path = os.path.join(self.label_path, txt_name)
    94.         xml_file = ET.parse(iter_anno_path) 
    95.     
    96.         root = xml_file.getroot()
    97.     
    98.         try:
    99.             with open(iter_image_path, 'rb') as f:
    100.                 check = f.read()[-2:]
    101.             if check != b'\xff\xd9':
    102.                 print('JPEG File collapse:', iter_image_path)
    103.                 a = cv2.imdecode(np.fromfile(iter_image_path,dtype=np.uint8),-1)
    104.                 cv2.imencode(".jpg", a)[1].tofile(iter_image_path)
    105.                 h,w = cv2.imdecode(np.fromfile(iter_image_path, dtype=np.uint8),-1).shape[:2]
    106.                 print('----------Rewrite & Read image successfully----------')
    107.  
    108.             else:
    109.                 h,w = cv2.imdecode(np.fromfile(iter_image_path,dtype=np.uint8),-1).shape[:2]
    110.         except:
    111.             print(iter_image_path)
    112.         
    113.         if (w is not None) and (h is not None):
    114.             count = 0
    115.             for child in root.findall('object'):
    116.                 if child != '':
    117.                     count = count + 1
    118.             if count != 0:
    119.  
    120.                 string1 = []
    121.                 for obj in root.iter('object'):
    122.                     cls = obj.find('name').text
    123.                     
    124.                     if cls in self.classes:
    125.                         cls_id = self.classes.index(cls)
    126.                     else:
    127.                         print(cls)
    128.                         continue
    129.                     xmlbox = obj.find('bndbox')
    130.                     b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text),
    131.                         float(xmlbox.find('ymax').text))
    132.                     bb = self.convert((w, h), b)
    133.                     for a in bb:
    134.                         if float(a) > 1.0:
    135.                             print(iter_anno_path + "wrong xywh",bb)
    136.                             return
    137.  
    138.                     string1.append(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
    139.                 
    140.                 out_file = open(iter_txt_path, "w")
    141.                 for string in string1:
    142.                     out_file.write(string)
    143.                 out_file.close()
    144.             else:
    145.                 print('count=0')
    146.                 print(img_name)
    147.             
    148.         else:
    149.             print('wh is none')
    150.  
    151.     def moveNewData(self, ):
    152.         newImageDataPaths = os.listdir(self.img_path)
    153.         newAnnotationPaths  = os.listdir(self.anno_path)
    154.         newLabelPaths = os.listdir(self.label_path)
    155.         for idx in range(len(newAnnotationPaths)):
    156.             shutil.move(os.path.join(self.img_path, newImageDataPaths[idx]), os.path.join(self.txt_path, "images",newImageDataPaths[idx]) )
    157.             shutil.move(os.path.join(self.anno_path, newAnnotationPaths[idx]), os.path.join(self.txt_path, "Annotations",newAnnotationPaths[idx]) )
    158.             shutil.move(os.path.join(self.label_path, newLabelPaths[idx]), os.path.join(self.txt_path, "labels",newLabelPaths[idx]) )
    159.  
    160.     def run(self,):
    161.         
    162.         pbar = tqdm(total=(len(self.files)))
    163.         update = lambda *args: pbar.update()
    164.  
    165.         pool = Pool(6)
    166.  
    167.         for i, name in enumerate(self.files):
    168.             self.process(name)
    169.             print("Iter:[{}:{}]".format(i+1, len(self.files)))
    170.             '''
    171.             pool.apply_async必须在 if __main__ == "__main__"中被定义才可以使用；
    172.             这点以后优化得了，现在数据量少还用不上。
    173.             所以改成面对对象class类这样运行，多进程是不会有反应的。所以加了上面这个函数。
    174.             本来是没有的。
    175.             '''
    176.             pool.apply_async(self.process, args=(name), callback=update)
    177.             # pbar.update(1)
    178.         
    179.         pool.close()
    180.         pool.join()
    181.         img_names = ['.jpg','.JPG','.PNG','.png', '.jpeg']
    182.         for i, name in enumerate(self.files):
    183.             for j in img_names:
    184.                 img_name = os.path.splitext(name)[0] + j
    185.                 iter_image_path = os.path.join(self.img_path, img_name)
    186.                 if os.path.exists(iter_image_path):
    187.                     break
    188.  
    189.             if i in self.train_list:
    190.                 self.ftrain.write(iter_image_path + "\n")
    191.             else:
    192.                 self.ftest.write(iter_image_path + "\n")
    193.  
    194.             # writeAnnotation_path = os.path.join(self.img_path, os.path.splitext(name)[0] + '.xml')
    195.             # print("写入：", iter_image_path, writeAnnotation_path )
    196.         # 如果有只有图片没有xml的，需要生成空白txt
    197.         if self.anno_path == '':
    198.             imgs = os.listdir(self.img_path)
    199.             for img_name in imgs:
    200.                 txt_name = os.path.basename(img_name).split('.')[0] + '.txt'
    201.                 if not os.path.exists(os.path.join(self.label_path, txt_name)):
    202.                     _ = open(os.path.join(self.label_path, txt_name),'w')
    203.                 self.ftrain.write(os.path.join(self.img_path, img_name) + "\n")
    204.         if self.the_data_is_new:
    205.             self.moveNewData()
    206.  
    207. if __name__ == '__main__':
    208.     # tool = Tools_xml2yolo()
    209.     tool = Tools_xml2yolo(
    210.         img_path='datasets/jzl_zhoushan_train/images/',
    211.         anno_path='datasets/jzl_zhoushan_train/Annotations/',
    212.         label_path='datasets/jzl_zhoushan_train/labels/',
    213.         themeFIle='datasets/jzl_zhoushan_train/',
    214.         classes=["zsd_m","zsd_l","fhz_h","fhz_f","kk_f","kk_h","fhz_bs", "fhz_ycn","fhz_wcn","fhz_red_h", "fhz_green_f", "fhz_m", "bs_ur", "bs_ul", "bs_up", "bs_down", "fhz_ztyc", "bs_right", "bs_left", "bs_dl", "bs_dr", "kgg_ybh", "kgg_ybf", "yljdq_flow", "yljdq_stop"],
    215.         the_data_is_new=False)
    216.  
    217.     # themeFIle是原生数据集
    218.     # 前面三个参数是新增数据集子集
    219.     # the_data_is_new=True: 自动把images\Annotations\labels移到原生数据集对应images\Annotations\labels里面
    220.     # 默认把xml转换为yolo训练所需的txt格式
    221.     tool.run()

    🍉五、 使用yolo自动推理图片得到推理结果转换为训练所需xml

    1. import os
    2. import torch
    3. import xml.etree.ElementTree as ET
    4. from PIL import Image
    5.  
    6. # 分类类别名称字典
    7. class_dict = {
    8.     'zsd_m': '指示灯灭',
    9.     'zsd_l': '指示灯亮',
    10.     'fhz_h': '分合闸-合',
    11.     'fhz_f': '分合闸-分',
    12.     'fhz_ztyc': '分合闸-状态异常',
    13.     'fhz_bs': '旋转把手',
    14.     'kk_f': '空气开关-分',
    15.     'kk_h': '空气开关-合',
    16.     'fhz_ycn': '分合闸-已储能',
    17.     'fhz_wcn': '分合闸未储能',
    18.     'fhz_red_h': '分合闸-红-合',
    19.     'fhz_green_f': '分合闸-绿-分',
    20.     'fhz_m': '分合闸-灭',
    21.     'bs_ur': '把手-右上',
    22.     'bs_ul': '把手-左上',
    23.     'bs_up': '把手-上',
    24.     'bs_down': '把手-下',
    25.     'bs_right': '把手-右',
    26.     'bs_left': '把手-左',
    27.     'bs_dl': '把手-左下',
    28.     'bs_dr': '把手-右下',
    29.     "kgg_ybf": "开关柜-压板分",
    30.     "kgg_ybh": "开关柜-压板合",
    31.     "ddzsd_green":"带电指示灯-绿色",
    32.     "ddzsd_red":"带电指示灯-红色"
    33. }
    34.  
    35. def detect_and_save(model_path, folder_path, iter_start_index):
    36.     # 加载模型
    37.     model = torch.load(model_path, map_location=torch.device('cpu'))
    38.  
    39.     # 将模型设置为评估模式
    40.     model.eval()
    41.  
    42.     # 遍历文件夹下的每一张图片
    43.     for ind, file_name in enumerate(os.listdir(folder_path)):
    44.         if ind <= iter_start_index:
    45.             continue
    46.         if file_name.endswith('.jpg') or file_name.endswith('.png'):
    47.             # 打开图片
    48.             img_path = os.path.join(folder_path, file_name)
    49.             img = Image.open(img_path)
    50.  
    51.             # 进行推理
    52.             results = model(img)
    53.  
    54.             # 生成xml文件
    55.             root = ET.Element('annotation')
    56.             folder = ET.SubElement(root, 'folder')
    57.             folder.text = os.path.basename(folder_path)
    58.             filename = ET.SubElement(root, 'filename')
    59.             filename.text = file_name
    60.             size = ET.SubElement(root, 'size')
    61.             width = ET.SubElement(size, 'width')
    62.             width.text = str(img.width)
    63.             height = ET.SubElement(size, 'height')
    64.             height.text = str(img.height)
    65.             depth = ET.SubElement(size, 'depth')
    66.             depth.text = str(3)
    67.             for result in results.xyxy[0]:
    68.                 if result[-1] in class_dict:
    69.                     obj = ET.SubElement(root, 'object')
    70.                     name = ET.SubElement(obj, 'name')
    71.                     name.text = class_dict[result[-1]]
    72.                     bndbox = ET.SubElement(obj, 'bndbox')
    73.                     xmin = ET.SubElement(bndbox, 'xmin')
    74.                     xmin.text = str(int(result[0]))
    75.                     ymin = ET.SubElement(bndbox, 'ymin')
    76.                     ymin.text = str(int(result[1]))
    77.                     xmax = ET.SubElement(bndbox, 'xmax')
    78.                     xmax.text = str(int(result[2]))
    79.                     ymax = ET.SubElement(bndbox, 'ymax')
    80.                     ymax.text = str(int(result[3]))
    81.  
    82.             # 保存xml文件
    83.             xml_path = os.path.join(folder_path, os.path.splitext(file_name)[0] + '.xml')
    84.             tree = ET.ElementTree(root)
    85.             tree.write(xml_path)
    86.  
    87. if __name__ == "__main__":
    88.     detect_and_save('./best.pt', './rmwrite_zhoushan/rmwrite_zhoushan', iter_start_index=180)
  • 相关阅读:
    Linux命令
    Bio-Helix丨Bio-Helix艾美捷Ponceaus S染色液说明书
    你的凭据不工作（Win10远程桌面Win10）详细解决路线
    详解TCP/IP协议第四篇：数据在网络中传输方式的分类概述
    Kafka在企业级应用中的实践
    基于SpringBoot+Vue的校园招聘管理系统（Java毕业设计）
    4.5 MongoDB 文档存储
    Go语言学习笔记——使用swagger生成api接口文档
    （C语言）求解二元一次方程组
    数据分析技能点-概括性度量
  • 原文地址：https://blog.csdn.net/qq_51831335/article/details/134429297