PaddleDetect图像目标检测模型训练之数据标注——使用labelme进行标注

0 前言

在做PaddleDetect图像检测模型训练时，需要对数据集进行人工标注，下面将已货车检测为例，使用labelme进行标注的详细过程记录一下，以防日后忘记。

本文中使用到的文件请到这里下载：https://download.csdn.net/download/loutengyuan/87616492

1 labelme环境搭建

labelme是图形图像注释工具，它是用Python编写的，并将Qt用于其图形界面。说直白点，它是有界面的， 像软件一样，可以交互，但是它又是由命令行启动的，比软件的使用稍微麻烦点。其界面如下图：

注：这里界面我做过汉化，原本是英文的，下面会提供汉化的文件。

1.1 labelme工具安装

请先打开cmd命令窗口，在输入以下命令进行安装：

# -i 是指定国内镜像源，提高安装速度
pip install labelme -i https://mirror.baidu.com/pypi/simple

查看是否安装可以使用以下命令：

pip list

1.2 labelme汉化

将labelme汉化文件（下载目录中的app.py文件）替换到以下目录（这里以你实际安装目录为准）：

C:\Users\Administrator\AppData\Local\Programs\Python\Python310\Lib\site-packages\labelme

2 标注操作流程

打开下载文件，可以看到如下文件：

• truck_detect：待标注图片
• app.py：labelme汉化文件
• labels.txt：标注标签列表
• 双击打开标注工具.bat：启动脚本

2.1 打开标注工具

本来启动labelme软件是通过命令行方式启动的，这里我将这个命令到到 双击打开标注工具.bat 文件中了，所以只需双击这个脚本就能打开labelme工具了，启动脚本内容如下：

:: 进入当前目录
cd  %~dp0
labelme truck_detect --labels labels.txt
pause

2.2 开启自动保存选项

• 选择 File -> Save Automatically 自动保存选项

新建标注

选择 绘制矩形 或者 绘制多边形 选项

执行以下步骤，安装标签类型标出图片中各个区域位置，然后点击下一张，所画的区域将自动保存：

2.3 编辑/修改标注

如果标签选错或者区域要调整，可以点击编辑选择，选中需要编辑的区域进行修改，或者鼠标右键选择 编辑标签 进行修改。

2.4 标注文件

标注好的文件和图片都保存在 truck_detect 文件夹下：

标签文件为json格式，内容如下：

{"version":"5.1.1",
  "flags":{},
  "shapes":[{"label":"整车侧面",
      "points":[[96.73611111111113,
          66.625],
        [446.0416666666667,
          290.23611111111114]],
      "group_id": null,
      "shape_type":"rectangle",
      "flags":{}},
    {"label":"车头侧面",
      "points":[[101.59722222222224,
          70.79166666666666],
        [299.5138888888889,
          294.40277777777777]],
      "group_id": null,
      "shape_type":"rectangle",
      "flags":{}},
    {"label":"车轮侧面",
      "points":[[177.29166666666669,
          188.84722222222223],
        [431.45833333333337,
          288.84722222222223]],
      "group_id": null,
      "shape_type":"rectangle",
      "flags":{}},
    {"label":"车身侧面",
      "points":[[290.48611111111114,
          70.79166666666666],
        [439.09722222222223,
          279.125]],
      "group_id": null,
      "shape_type":"rectangle",
      "flags":{}}],
  "imagePath":"81675.jpg_800x533.jpg",
  "imageData":"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",
  "imageHeight":327,
  "imageWidth":490}

3 格式转换

常用的目标检测数据集有两种格式，分别是VOC和COCO。

3.1 转COCO格式

如果使用COCO格式，建议使用PaddleDetection中的x2coco将标注好的文件转为COCO格式的数据集。转换代码如下：

python tools/x2coco.py \
                --dataset_type labelme \
                --json_input_dir ./labelme_annos/ \
                --image_input_dir ./labelme_imgs/ \
                --output_dir ./cocome/ \
                --train_proportion 0.8\
                --val_proportion 0.2\
                --test_proportion 0.0

3.2 转VOC格式

本项目使用VOC格式的数据集，使用下面代码将数据集转成VOC2007格式：

import os
import numpy as np
import codecs
import json
from glob import glob
import cv2
import shutil

# 标签路径
labelme_path ="D:/DataProcess/vehicle/truck_detect/truck_detect/"# 原始labelme标注数据路径
saved_path ="D:/DataProcess/vehicle/truck_detect/truck_detect_voc/"# 保存路径# 将中文标签名称转换成英文字母
label_translate_dict ={"车头正面":"head_front",
    "车头侧面":"head_side",
    "车身侧面":"body_side",
    "车轮侧面":"wheel_side",
    "整车侧面":"vehicle_side",
    "工程车":"vehicle_side"# engine_truck}

label_txt =["__ignore__", "_background_"]# 创建要求文件夹if not os.path.exists(saved_path + "Annotations"):
    os.makedirs(saved_path + "Annotations")if not os.path.exists(saved_path + "JPEGImages/"):
    os.makedirs(saved_path + "JPEGImages/")# 获取待处理文件
files = glob(labelme_path + "*.json")
files =[i.split("\\")[-1].split(".json")[0]foriin files]
total_len = len(files)
total_idx =0

out_count =0
skip_count =0
err_count =0# 读取标注信息并写入 xmlforjson_file_in files:
    total_idx +=1if" "in json_file_:
        continue
    json_filename = labelme_path + json_file_ + ".json"
    img_filename = labelme_path + json_file_ + ".jpg"if not os.path.exists(json_filename) or not os.path.exists(img_filename):
        continue
    json_file = json.load(open(json_filename, "r", encoding="utf-8"))if total_idx % 100==0:
        print("进度：{}".format((total_idx / total_len)*100))

    imagePath = json_file["imagePath"]if json_file_ not in imagePath:
        err_count +=1
        print("imagePath error fileName = {}    imagePath = {}".format(json_file_, imagePath))continue

    height, width, channels = cv2.imread(img_filename).shape
    success_count =0
    xml_filename = saved_path + "Annotations/" + json_file_ + ".xml"
    with codecs.open(xml_filename, "w", "utf-8") as xml:
        xml.write('<annotation>\n')
        xml.write('\t<folder>' + 'UAV_data' + '</folder>\n')
        xml.write('\t<filename>' + json_file_ + ".jpg" + '</filename>\n')
        xml.write('\t<source>\n')
        xml.write('\t\t<database>The UAV autolanding</database>\n')
        xml.write('\t\t<annotation>UAV AutoLanding</annotation>\n')
        xml.write('\t\t<image>flickr</image>\n')
        xml.write('\t\t<flickrid>NULL</flickrid>\n')
        xml.write('\t</source>\n')
        xml.write('\t<owner>\n')
        xml.write('\t\t<flickrid>NULL</flickrid>\n')
        xml.write('\t\t<name>ChaojieZhu</name>\n')
        xml.write('\t</owner>\n')
        xml.write('\t<size>\n')
        xml.write('\t\t<width>' + str(width) + '</width>\n')
        xml.write('\t\t<height>' + str(height) + '</height>\n')
        xml.write('\t\t<depth>' + str(channels) + '</depth>\n')
        xml.write('\t</size>\n')
        xml.write('\t\t<segmented>0</segmented>\n')formultiin json_file["shapes"]:
            points = np.array(multi["points"])
            xmin = min(points[:, 0])
            xmax = max(points[:, 0])
            ymin = min(points[:, 1])
            ymax = max(points[:, 1])if"未知"in multi["label"]:
                breakforkeyin label_translate_dict.keys():
                if key in multi["label"]:
                    label = label_translate_dict[key]breakif label is None:
                continueif label not in label_txt:
                label_txt.append(label)if xmax <= xmin:
                continueelif ymax <= ymin:
                continueelif(xmax - xmin) * (ymax - ymin)<1000:
                continue
            else:
                xml.write('\t<object>\n')
                xml.write('\t\t<name>' + label + '</name>\n')
                xml.write('\t\t<pose>Unspecified</pose>\n')
                xml.write('\t\t<truncated>1</truncated>\n')
                xml.write('\t\t<difficult>0</difficult>\n')
                xml.write('\t\t<bndbox>\n')
                xml.write('\t\t\t<xmin>' + str(xmin) + '</xmin>\n')
                xml.write('\t\t\t<ymin>' + str(ymin) + '</ymin>\n')
                xml.write('\t\t\t<xmax>' + str(xmax) + '</xmax>\n')
                xml.write('\t\t\t<ymax>' + str(ymax) + '</ymax>\n')
                xml.write('\t\t</bndbox>\n')
                xml.write('\t</object>\n')# print(total_idx, total_len, json_filename, xmin, ymin, xmax, ymax, label)
                success_count +=1
        xml.write('</annotation>')if success_count >0:
        shutil.copy(img_filename, saved_path + "JPEGImages/")
        out_count +=1
    else:
        skip_count +=1if os.path.exists(xml_filename):
            os.remove(xml_filename)# 写标签文件
labels_txt_writer = open(saved_path + '/labels.txt', 'w')fortextin label_txt:
    labels_txt_writer.write(text + "\n")
labels_txt_writer.close()

print("-------------------------------- Finished  --------------------------------")
print("out_count = {}".format(out_count))
print("skip_count = {}".format(skip_count))
print("err_count = {}".format(err_count))
print("label_txt = {}".format(label_txt))

3.3 输出标注区域

下面这个脚本是用于将标签json文件解析，并将结果单独裁剪或绘制到图像中，用于查看标注效果：

import os
import numpy as np
import json
from glob import glob
import cv2
from PIL import Image, ImageDraw, ImageFont

labelme_path ="D:/DataProcess/vehicle/truck_detect/truck_detect/"# 原始labelme标注数据路径# 输出文件夹路径
outputPath ="D:/DataProcess/vehicle/predict_output/"

files = glob(labelme_path + "*.json")
files =[i.split("\\")[-1].split(".json")[0]foriin files]
files_size = len(files)# 将区域裁剪单独保存
def clip_save():
    file_idx =0forjson_file_in files:
        file_idx +=1if" "in json_file_:
            continue
        json_filename = labelme_path + json_file_ + ".json"
        img_filename = labelme_path + json_file_ + ".jpg"if not os.path.exists(json_filename) or not os.path.exists(img_filename):
            continue
        json_file = json.load(open(json_filename, "r", encoding="utf-8"))# image = cv2.imread(img_filename)
        image = cv2.imdecode(np.fromfile(img_filename, dtype=np.uint8), -1)# height, width, channels = image.shape# "车头正面", "车头侧面", "车身侧面", "车轮侧面", "整车侧面", "工程车"forlabel_namein["车头正面", "车头侧面"]:
            outputLabelPath = outputPath + label_name + "/"if not os.path.exists(outputLabelPath):
                os.makedirs(outputLabelPath)
            idx =0formultiin json_file["shapes"]:
                points = np.array(multi["points"])
                xmin = min(points[:, 0])
                xmax = max(points[:, 0])
                ymin = min(points[:, 1])
                ymax = max(points[:, 1])#     "车头正面", "车头侧面", "车身侧面", "车轮侧面", "整车侧面"
                label = multi["label"]if label_name not in label:
                    continueif xmax <= xmin:
                    continueelif ymax <= ymin:
                    continueelif(xmax - xmin) * (ymax - ymin)<1000:
                    continue
                else:
                    print("{}/{} {} {} {} {} {} {}".format(file_idx, files_size, json_filename, xmin, ymin, xmax, ymax,
                                                           label))# 将主体区域裁剪后保存到输出文件夹 #参数1 是高度的范围，参数2是宽度的范围
                    img_crop = image[int(ymin):int(ymax), int(xmin):int(xmax)]if idx ==0:
                        out_image_file = outputLabelPath + json_file_ + ".jpg"
                    else:
                        out_image_file = outputLabelPath + "crop_" + str(idx) + "_" + json_file_ + ".jpg"# cv2.imwrite(out_image_file, img_crop)
                    cv2.imencode('.jpg', img_crop)[1].tofile(out_image_file)

                    idx +=1# 将结果绘制到一张图片
def draw_save():
    file_idx =0forjson_file_in files:
        file_idx +=1if" "in json_file_:
            continue
        json_filename = labelme_path + json_file_ + ".json"
        img_filename = labelme_path + json_file_ + ".jpg"if not os.path.exists(json_filename) or not os.path.exists(img_filename):
            continue
        json_file = json.load(open(json_filename, "r", encoding="utf-8"))# image = cv2.imread(img_filename)
        image = cv2.imdecode(np.fromfile(img_filename, dtype=np.uint8), -1)[:, :, ::-1]if isinstance(image, np.ndarray):
            image = Image.fromarray(image)# height, width, channels = image.shape
        is_success = False
        formultiin json_file["shapes"]:
            points = np.array(multi["points"])
            xmin = min(points[:, 0])
            xmax = max(points[:, 0])
            ymin = min(points[:, 1])
            ymax = max(points[:, 1])#     "车头正面", "车头侧面", "车身侧面", "车轮侧面", "整车侧面"
            label = multi["label"]
            tag = False
            fortextin["车头正面"]:
                if text in label:
                    tag = True
                    breakif not tag:
                continueif xmax <= xmin:
                continueelif ymax <= ymin:
                continue
            else:
                is_success = True
                print("{}/{} {} {} {} {} {} {}".format(file_idx, files_size, json_filename, xmin, ymin, xmax, ymax,
                                                       label))
                draw = ImageDraw.Draw(image)
                font_size =36# simfang.ttf 这个文件在下载包中有
                font = ImageFont.truetype("./simfang.ttf", font_size, encoding="utf-8")
                text ="标签：{}".format(multi["label"])
                th = font_size
                tw = font.getsize(text)[0]# tw = int(len(result["rec_docs"]) * font_size) + 60
                start_y = max(0, ymin - th)

                draw.rectangle([(xmin + 1, start_y), (xmin + tw + 1, start_y + th)], fill=(0, 102, 255))

                draw.text((xmin + 1, start_y), text, fill=(255, 255, 255), font=font)

                draw.rectangle([(xmin, ymin), (xmax, ymax)], outline=(255, 0, 0), width=2)if is_success:
            # image.show(img_filename)

            os.makedirs(outputPath, exist_ok=True)
            output_path = os.path.join(outputPath, json_file_ + ".jpg")

            image.save(output_path, quality=95)if __name__ =='__main__':# 将结果单独裁剪保存
    clip_save()# # 将结果绘制到同一张图片上保存# draw_save()