Algorithm-Repo/SourceCode/MachineLearningUtils/TestTools/AIModelMetricsUtils/gt_file_generate.py

"""
将平台的标注信息，装换成所需要的gt格式文件
分为分类，检测，语义分割，三种不同的格式
后续添加实例分割的格式，直接添加函数即可
"""
import json

import numpy as np

"""
将平台的标注格式转成计算metrics所需的格式

平台提供的label_info标注格式，注释如下:"Rois"中存放roi标签，"ImageResults"中存放图像标签
{
"Id": " ",
"Rois":
    [
        {
            "Id": " ",
            "Index": 0,
            "Points": [ "254, 122", "253, 122" ],
            "Descriptions": [],
            "Conclusion":
             {
                "Id": " ",
                "Title": " ",
                "IsRegion": false,
                "IsUnique": false
            },
            "Unit": 
            {
                "Id": " ",
                "Title": " ",
                "RegionRequired": false
            }
        }
        ,
        {多个roi标签时，多个表示，"Index"需要调整加1}
    ],
"ImageResults":
    [
        {
            "Id": "waTJBlDmo8Oj4xvh",
            "Index": 0,
            "Descriptions": [],
            "Conclusion": 
            {
                "Id": "",
                "Title": "",
                "IsRegion": false,
                "IsUnique": false
            },
            "Unit": 
            {
                "Id": "8YhRbEaKl10woNgM",
                "Title": "肝脏",
                "RegionRequired": false
            }
        }
        ,
        {多个图像标签时，多个表示，"Index"需要调整加1}
    ],
"Unit":
    {
        "Id": " ",
        "Title": " ",
        "RegionRequired": false
    }
}


预测metrics所需的格式：

分类：
[{'Label': 0, 'Confidence': 1.0}]
[]

检测：
[{'Label': 1, 'Confidence': 1.0, 'BoundingBox'：[2, 3, 4, 5]}]
[{'Label': 1, 'Confidence': 1.0, 'BoundingBox'：[2, 3, 4, 5]},{'Label': 2, 'Confidence': 1.0, 'BoundingBox'：[2, 3, 4, 5]}]
[{'Label': 0, 'Confidence': 1.0, 'BoundingBox'：[0, 0, 0, 0]}]
[]

语义分割：
[{'Label': 0, 'Confidence': 1.0, 'Image_size':[w, h], 'Contour': []}]
[{'Label': 1, 'Confidence': 1.0, 'Image_size':[w, h], 'Contours'：[ [ [1,2],[3,4] ] , [ [5,6],[7,8] ]  ]}]
[{'Label': 1, 'Confidence': 1.0, 'Image_size':[w, h], 'Contours'：[ [ [1,2],[3,4] ]  ]}]
[{'Label': 1, 'Confidence': 1.0, ''Image_size':[w, h], Contours'：[ [ [1,2],[3,4] ]  ]},{'Label': 2, 'Confidence': 1.0, 'Contours'：[ [ [1,2],[3,4] ]  ]}]
[]

"""


def gtfilegenerate_classifications(label_info,
                                   image_size,
                                   needed_imageresults_dict,
                                   needed_rois_dict,
                                   class_id_map):
    """
    设置所需的gt格式,返回需要的json格式
    适用于:导航的分类网络，判断乳腺腹部等扫查部分分类网络

    :param label_info:平台提供的label_info标注格式
    :param needed_imageresults_dict: 图像标签
    :param needed_rois_dict: roi标签
    :param class_id_map: 用于label改变的dict
    :return: 返回gt的json格式文件
                output_info = {'Label': 0, 'Confidence': 1.0}
    """
    labeled_result = label_info[0]["FileResultInfos"][0]["LabeledResult"]
    output_info_list = []

    # 图像标签判断
    for image_result in labeled_result["ImageResults"]:
        image_cls = image_result["Conclusion"]["Title"]
        if image_cls in needed_imageresults_dict.keys():
            output_info = {'Label': 0, 'Confidence': 1.0}
            output_info['Label'] = class_id_map[needed_imageresults_dict[image_cls]]
            output_info_list.append(output_info)

    # roi标签判断
    for each_roi_label in label_info["Rois"]:
        roi_cls = each_roi_label["Conclusion"]["Title"]
        if roi_cls in needed_rois_dict.keys():
            output_info = {'Label': 0,
                           'Confidence': 1.0}
            output_info['Label'] = class_id_map[needed_rois_dict[roi_cls]]
            output_info_list.append(output_info)

    # 保证输出的output_info_list
    if len(output_info_list) == 0:
        print('label_info为：{} 的图像，无法匹配任何所需的imageresults和rois的title，该图像作废'.format(label_info))
        return json.dumps([], ensure_ascii=False)
    elif len(output_info_list) > 1:
        print('label_info为：{} 的图像，图像匹配多个imageresults和rois的title，该图像作废'.format(label_info))
        return json.dumps([], ensure_ascii=False)
    else:
        return json.dumps(output_info_list, ensure_ascii=False)


def gtfilegenerate_classifications_liverdiffuselesionclassifier(label_info,
                                                                image_size,
                                                                needed_imageresults_dict,
                                                                needed_rois_dict,
                                                                class_id_map):
    """
    设置所需的gt格式,返回需要的json格式
    适用于:肝脏弥漫性疾病分类

    :param label_info:平台提供的label_info标注格式
    :param needed_imageresults_dict: 图像标签
    :param needed_rois_dict: roi标签
    :param class_id_map: 用于label改变的dict
    :return: 返回gt的json格式文件
                output_info = {'Label': 0, 'Confidence': 1.0}
    """
    labeled_result = label_info[0]["FileResultInfos"][0]["LabeledResult"]
    output_info_list = []
    temp_list = []

    # roi标签判断
    for each_roi_label in range(len(labeled_result["Rois"])):
        roi_cls = each_roi_label["Conclusion"]["Title"]
        if roi_cls in needed_rois_dict.keys():
            output_info = {'Label': 0,
                           'Confidence': 1.0}
            output_info['Label'] = class_id_map[needed_rois_dict[roi_cls]]
            output_info_list.append(output_info)
            temp_list.append(roi_cls)

    # 肝脏弥漫性分类，比较特殊，因为标注问题，会出现：标注一个肝的轮廓，再标注一个弥漫性疾病的情况，分类标签无法确定
    # 根据rois标签的title，将'肝脏未见明显异常'删除
    if len(output_info_list) == 2 and len(temp_list) == 2:
        for roi_cls in temp_list:
            if roi_cls == '肝脏未见明显异常':
                output_info_list.pop(temp_list.index(roi_cls))

    # 保证输出的output_info_list
    if len(output_info_list) == 0:
        print('label_info为：{} 的图像，无法匹配任何所需的imageresults和rois的title，该图像作废'.format(label_info))
        return json.dumps([], ensure_ascii=False)
    elif len(output_info_list) > 1:
        print('label_info为：{} 的图像，图像匹配多个imageresults和rois的title，该图像作废'.format(label_info))
        return json.dumps([], ensure_ascii=False)
    else:
        return json.dumps(output_info_list, ensure_ascii=False)


def gtfilegenerate_objectdetection(label_info,
                                   image_size,
                                   needed_imageresults_dict,
                                   needed_rois_dict,
                                   class_id_map):
    """
    设置所需的gt格式,返回需要的json格式
    适用于: 乳腺检测，肝脏局灶性疾病检测

    :param label_info:平台提供的label_info标注格式
    :param needed_imageresults_dict: 图像标签
    :param needed_rois_dict: roi标签
    :param class_id_map: 用于label改变的dict
    :return: 返回gt的json格式文件
                output_info = {'Label': 0, 'Confidence': 1.0, 'BoundingBox'：[0, 0, 0, 0]}
                output_info = {'Label': 1, 'Confidence': 1.0, 'BoundingBox'：[2, 3, 4, 5]}
                BoundingBox格式：left，top，right，bottom
    """
    labeled_result = label_info[0]["FileResultInfos"][0]["LabeledResult"]
    output_info_list = []

    # 图像标签判断
    for image_result in labeled_result["ImageResults"]:
        image_cls = image_result["Conclusion"]["Title"]
        if image_cls in needed_imageresults_dict.keys():
            output_info = {'Label': class_id_map[needed_imageresults_dict[image_cls]],
                           'Confidence': 1.0,
                           'BoundingBox': [0, 0, 0, 0]}
            output_info_list.append(output_info)

    for each_roi_label in labeled_result["Rois"]:
        roi_cls = each_roi_label["Conclusion"]["Title"]
        if roi_cls in needed_rois_dict.keys():
            roi_points = each_roi_label["Points"]
            x, y = [], []
            for point in roi_points:
                x.append(int(point["X"]))
                y.append(int(point["Y"]))
            left, right = min(x), max(x)
            top, bottom = min(y), max(y)
            roi_boundingbox = [left, top, right, bottom]
            output_info = {'Label': class_id_map[needed_rois_dict[roi_cls]],
                           'Confidence': 1.0,
                           'BoundingBox': roi_boundingbox}
            output_info_list.append(output_info)

    # 保证输出的output_info_list
    if len(output_info_list) == 0:
        print('label_info为：{} 的图像，无法匹配任何所需的imageresults和rois的title，该图像作废'.format(label_info))
        return json.dumps([], ensure_ascii=False)
    else:
        return json.dumps(output_info_list, ensure_ascii=False)


def gtfilegenerate_objectdetection_liverfocalobd(label_info,
                                                 image_size,
                                                 needed_imageresults_dict,
                                                 needed_rois_dict,
                                                 class_id_map):
    """
    设置所需的gt格式,返回需要的json格式
    适用于: 乳腺检测，肝脏局灶性疾病检测

    :param label_info:平台提供的label_info标注格式
    :param needed_imageresults_dict: 图像标签
    :param needed_rois_dict: roi标签
    :param class_id_map: 用于label改变的dict
    :return: 返回gt的json格式文件
                output_info = {'Label': 0, 'Confidence': 1.0, 'BoundingBox'：[0, 0, 0, 0]}
                output_info = {'Label': 1, 'Confidence': 1.0, 'BoundingBox'：[2, 3, 4, 5]}
                BoundingBox格式：left，top，right，bottom
    """
    labeled_result = label_info[0]["FileResultInfos"][0]["LabeledResult"]
    output_info_list = []
    output_label = []

    for each_roi_label in labeled_result["Rois"]:
        roi_cls = each_roi_label["Conclusion"]["Title"]

        if roi_cls in needed_rois_dict.keys():
            roi_points = each_roi_label["Points"]
            x, y = [], []
            for point in roi_points:
                x.append(int(point["X"]))
                y.append(int(point["Y"]))
            left, right = min(x), max(x)
            top, bottom = min(y), max(y)
            roi_boundingbox = [left, top, right, bottom]
            output_info = {'Label': class_id_map[needed_rois_dict[roi_cls]],
                           'Confidence': 1.0,
                           'BoundingBox': roi_boundingbox}
            output_info_list.append(output_info)
            if roi_cls == "肝脏未见明显异常":
                output_label.append(-1)
            else:
                output_label.append(class_id_map[needed_rois_dict[roi_cls]])

    if len(output_info_list) > 1:
        if (-1 in output_label) and (np.array(output_label) > 0).any():
            print('label_info为：{} 的图像，既标注了未见明显异常，又标注了弥漫性疾病，该图像作废'.format(label_info))
            return json.dumps([], ensure_ascii=False)
        elif (np.array(output_label) <= 0).all():
            return json.dumps([{'Label': 0, 'Confidence': 1.0, 'BoundingBox': [0, 0, 0, 0]}], ensure_ascii=False)
        else:
            output_info_list_new = []
            for i in range(len(output_info_list)):
                if output_info_list[i]['Label'] != 0:
                    output_info_list_new.append(output_info_list[i])
            return json.dumps(output_info_list_new, ensure_ascii=False)
    elif len(output_info_list) == 1:
        if output_info_list[0]['Label'] == 0:
            return json.dumps([{'Label': 0, 'Confidence': 1.0, 'BoundingBox': [0, 0, 0, 0]}], ensure_ascii=False)
        else:
            return json.dumps(output_info_list, ensure_ascii=False)
    else:
        print('label_info为：{} 的图像，无法匹配任何所需的imageresults和rois的title，该图像作废'.format(label_info))
        return json.dumps(output_info_list, ensure_ascii=False)


def gtfilegenerate_semantic_segmentation(label_info,
                                         image_size,
                                         needed_imageresults_dict,
                                         needed_rois_dict,
                                         class_id_map):
    """
    设置所需的gt格式,返回需要的json格式
    适用于: 语义分割

    :param label_info:
    :param needed_imageresults_dict:
    :param needed_rois_dict:
    :param class_id_map: 用于label改变的dict
    :return:
        output_info = {'Label': 0, 'Image_size':[20, 50], 'Confidence': 1.0, 'Contours'：[]}
        output_info = {'Label': 0, 'Image_size':[20, 50], 'Confidence': 1.0, 'Contours'：[ [ [1,2],[3,4] ]  ]}
    """
    labeled_result = label_info[0]["FileResultInfos"][0]["LabeledResult"]
    output_info_list = []

    for image_result in labeled_result["ImageResults"]:
        image_cls = image_result["Conclusion"]["Title"]
        if image_cls in needed_imageresults_dict.keys():
            output_info = {'Label': class_id_map[needed_imageresults_dict[image_cls]], 'Image_size': image_size,
                           'Confidence': 1.0, 'Contours': []}
            output_info_list.append(output_info)

    for each_roi_label in labeled_result["Rois"]:
        roi_cls = each_roi_label["Conclusion"]["Title"]
        if roi_cls in needed_rois_dict.keys():
            roi_points = each_roi_label["Points"]
            roi_contour = []
            for point in roi_points:
                roi_contour.append([int(point["X"]), int(point["Y"])])
            output_info = {'Label': 0,
                           'Image_size': image_size,
                           'Confidence': 1.0,
                           'Contours': []}
            output_info['Label'] = class_id_map[needed_rois_dict[roi_cls]]
            output_info['Contours'].append(roi_contour)
            output_info_list.append(output_info)

    # 保证输出的output_info_list
    if len(output_info_list) == 0:
        print('label_info为：{} 的图像，无法匹配任何所需的imageresults和rois的title，该图像作废'.format(label_info))
        return json.dumps([], ensure_ascii=False)
    else:
        return json.dumps(output_info_list, ensure_ascii=False)


def gtfilegenerate_semantic_segmentation_liverfocalSeg(label_info,
                                                       image_size,
                                                       needed_imageresults_dict,
                                                       needed_rois_dict,
                                                       class_id_map):
    """
    设置所需的gt格式,返回需要的json格式

    :param label_info:平台提供的label_info标注格式
    :param needed_imageresults_dict: 图像标签
    :param needed_rois_dict: roi标签
    :param class_id_map: 用于label改变的dict
    :return: 返回gt的json格式文件
                output_info = {'Label': 0, 'Confidence': 1.0, 'BoundingBox'：[0, 0, 0, 0]}
                output_info = {'Label': 1, 'Confidence': 1.0, 'BoundingBox'：[2, 3, 4, 5]}
                BoundingBox格式：left，top，right，bottom
    """
    labeled_result = label_info[0]["FileResultInfos"][0]["LabeledResult"]
    output_info_list = []
    output_label = []

    for each_roi_label in labeled_result["Rois"]:
        roi_cls = each_roi_label["Conclusion"]["Title"]
        if roi_cls in needed_rois_dict.keys():
            roi_points = each_roi_label["Points"]
            roi_contour = []
            for point in roi_points:
                roi_contour.append([int(point["X"]), int(point["Y"])])
            output_info = {'Label': class_id_map[needed_rois_dict[roi_cls]],
                           'Image_size': image_size,
                           'Confidence': 1.0,
                           'Contours': []}
            output_info['Contours'].append(roi_contour)
            output_info_list.append(output_info)
            if roi_cls == "肝脏未见明显异常":
                output_label.append(-1)
            else:
                output_label.append(class_id_map[needed_rois_dict[roi_cls]])

    if len(output_info_list) > 1:
        if (-1 in output_label) and (np.array(output_label) > 0).any():
            print('label_info为：{} 的图像，既标注了未见明显异常，又标注了弥漫性疾病，该图像作废'.format(label_info))
            return json.dumps([], ensure_ascii=False)
        elif (np.array(output_label) <= 0).all():
            return json.dumps([{'Label': 0, 'Image_size': image_size, 'Confidence': 1.0, 'Contours': []}],
                              ensure_ascii=False)
        else:
            output_info_list_new = []
            for i in range(len(output_info_list)):
                if output_info_list[i]['Label'] != 0:
                    output_info_list_new.append(output_info_list[i])
            return json.dumps(output_info_list_new, ensure_ascii=False)
    elif len(output_info_list) == 1:
        if output_info_list[0]['Label'] == 0:
            return json.dumps([{'Label': 0, 'Image_size': image_size, 'Confidence': 1.0, 'Contours': []}],
                              ensure_ascii=False)
        else:
            return json.dumps(output_info_list, ensure_ascii=False)
    else:
        print('label_info为：{} 的图像，无法匹配任何所需的imageresults和rois的title，该图像作废'.format(label_info))
        return json.dumps(output_info_list, ensure_ascii=False)


def gtfilegenerate_semantic_segmentation_myocardial(label_info,
                                                    image_size,
                                                    needed_imageresults_dict,
                                                    needed_rois_dict,
                                                    class_id_map):
    """
    设置所需的gt格式,返回需要的json格式
    适用于: 心肌的语义分割
    一般的语义分割中，如果有多个相同title的roi标签，则算多个病灶或者部位
    心肌出现的情况是：只有两种情况：存在两个相同title的roi标签，是环形心肌（此时需要将两个轮廓放在一起）；一个title的roi标签，是u型心肌

    :param label_info:
    :param needed_imageresults_dict:
    :param needed_rois_dict:
    :param class_id_map: 用于label改变的dict
    :return:
        output_info = {'Label': 0, 'Image_size':[20, 50], 'Confidence': 1.0, 'Contours'：[]}
        output_info = {'Label': 0, 'Image_size':[20, 50], 'Confidence': 1.0, 'Contours'：[ [ [1,2],[3,4] ]  ]}
        output_info = {'Label': 0, 'Image_size':[20, 50], 'Confidence': 1.0, 'Contours'：[ [ [1,2],[3,4] ] , [ [5,6],[7,8] ]  ]}
    """
    labeled_result = label_info[0]["FileResultInfos"][0]["LabeledResult"]
    output_info_list = []

    # 图像标签判断
    for image_result in labeled_result["ImageResults"]:
        image_roi = image_result["Conclusion"]["Title"]
        if image_roi in needed_imageresults_dict.keys():
            output_info = {'Label': class_id_map[needed_imageresults_dict[image_roi]],
                           'Image_size': image_size,
                           'Confidence': 1.0,
                           'Contours': []}
            output_info_list.append(output_info)

    for each_roi_label in labeled_result["Rois"]:
        roi_cls = each_roi_label["Conclusion"]["Title"]
        if roi_cls in needed_rois_dict.keys():
            roi_points = each_roi_label["Points"]
            roi_contour = []
            for point in roi_points:
                roi_contour.append([int(point["X"]), int(point["y"])])
            output_info = {'Label': class_id_map[needed_rois_dict[roi_cls]],
                           'Image_size': image_size,
                           'Confidence': 1.0,
                           'Contours': []}
            output_info['Contours'].append(roi_contour)
            output_info_list.append(output_info)

    if len(output_info_list) == 2:
        if output_info_list[0]['Label'] == output_info_list[1]['Label']:
            output_info_list[0]['Contours'].append(output_info_list[1]['Contours'][0])
            output_info_list.pop(1)
        else:
            print('label_info为：{} 的图像，匹配两个不同title的rois标签，该图像作废'.format(label_info))
            return json.dumps([], ensure_ascii=False)

    if len(output_info_list) >= 3:
        print('label_info为：{} 的图像，匹配三个以上所需的imageresults和rois的title，该图像作废'.format(label_info))
        return json.dumps([], ensure_ascii=False)
    elif len(output_info_list) == 0:
        print('label_info为：{} 的图像，无法匹配任何所需的imageresults和rois的title，该图像作废'.format(label_info))
        return json.dumps([], ensure_ascii=False)
    else:
        return json.dumps(output_info_list, ensure_ascii=False)