Upload metric.py

metric/metric.py

@@ -0,0 +1,1130 @@
+import os
+import json
+import re
+import math
+import statistics
+
+def read_json_file(file_path):
+    """
+    Reads a JSON file and returns the parsed data as a Python object.
+
+    :param file_path: The path to the JSON file
+    :return: The data parsed from the JSON file
+    """
+    with open(file_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    return data
+
+def clean_string(s: str) -> str:
+    """
+    Remove all non-alphanumeric characters from the input string,
+    including punctuation, whitespace, and escape characters.
+
+    :param s: The original string.
+    :return: A new string containing only letters and digits.
+    """
+    # Replace any character that is NOT a letter or digit with ''
+    return re.sub(r'[^A-Za-z0-9]+', '', s)
+
+def word_level_ac(texts, response, window_size: int = 5, step: int = 5):
+    if isinstance(texts, list):
+        gt = ""
+        for item in texts:
+            gt += clean_string(item)
+    if isinstance(texts, str):
+        gt = clean_string(texts)
+
+    if isinstance(response, list):
+        ocr = ""
+        for item in response:
+            ocr += clean_string(item)
+    if isinstance(response, str):
+        ocr = clean_string(response)
+
+    results = []
+    n = len(gt)
+    for i in range(0, n - window_size + 1, step):
+        substr = gt[i: i + window_size]
+        found = substr in ocr
+        # print(found)
+        results.append(found)
+    if not results:
+        print(0.0)
+        return 0.0
+
+    ac = sum(results) / len(results)
+    # print(ac)
+    return ac
+
+def logo_ocr_ac(texts, response):
+    if isinstance(texts, list):
+        gt = ""
+        for item in texts:
+            gt += clean_string(item)
+    if isinstance(texts, str):
+        gt = clean_string(texts)
+
+    if isinstance(response, list):
+        ocr = ""
+        for item in response:
+            ocr += clean_string(item)
+    if isinstance(response, str):
+        ocr = clean_string(response)
+
+    lower_gt = gt.lower()
+    lower_ocr = ocr.lower()
+
+    if lower_gt==lower_ocr:
+        return 1
+    else:
+        return 0
+
+def real_poster_ac(texts, response, word_mode = False):
+    if isinstance(texts, list):
+        gt = []
+        for item in texts:
+            gt.append(clean_string(item).lower())
+    if isinstance(texts, str):
+        gt = [clean_string(texts).lower()]
+
+    if isinstance(response, list):
+        ocr = ""
+        for item in response:
+            ocr += clean_string(item).lower()
+    if isinstance(response, str):
+        ocr = clean_string(response).lower()
+
+    if word_mode == False:
+        results = []
+        for i in range(0,len(gt)):
+            substr = gt[i]
+            if substr in ocr:
+                found = 1
+                results.append(found)
+            else:
+                found = 0
+                results.append(found)
+
+        ac = sum(results)/len(results)
+
+    if word_mode==True:
+        ac = word_level_ac(gt, ocr)
+
+    return ac
+
+def font_matching_ac(options, response):
+    if isinstance(options, list):
+        gt = ""
+        for item in options:
+            gt += (clean_string(item))
+    if isinstance(options, str):
+        gt = clean_string(options)
+
+    if isinstance(response, list):
+        answer = ""
+        for item in response:
+            answer += clean_string(item)
+    if isinstance(response, str):
+        answer = clean_string(response)
+
+    if len(answer) > 20:
+        return 0
+
+    if gt in answer:
+        return 1
+    else:
+        return 0
+
+def font_attr_ac(options, response):
+    if isinstance(options, list):
+        gt = ""
+        for item in options:
+            gt += (clean_string(item))
+    if isinstance(options, str):
+        gt = clean_string(options)
+
+    if isinstance(response, list):
+        answer = ""
+        for item in response:
+            answer += clean_string(item)
+    if isinstance(response, str):
+        answer = clean_string(response)
+
+    # if len(answer)>20:
+    #     return 0
+
+    if gt in answer:
+        return 1
+    else:
+        return 0
+
+
+def font_effect_ac(options, response):
+    if isinstance(options, list):
+        gt = ""
+        for item in options:
+            gt += (clean_string(item))
+    if isinstance(options, str):
+        gt = clean_string(options)
+
+    if isinstance(response, list):
+        answer = ""
+        for item in response:
+            answer += clean_string(item)
+    if isinstance(response, str):
+        answer = clean_string(response)
+
+    # if len(answer)>20:
+    #     return 0
+
+    if gt in answer:
+        return 1
+    else:
+        return 0
+
+def font_effect_2_ac(options: list, response):
+    if isinstance(response, list):
+        answer = ""
+        for item in response:
+            answer += clean_string(item)
+    if isinstance(response, str):
+        answer = clean_string(response)
+
+    if options[0] in answer:
+        color_ac = 1
+    else:
+        color_ac = 0
+
+    result = []
+    for i in range(1,len(options)):
+        found = options[i] in answer
+        result.append(found)
+    if len(result)==0:
+        return color_ac, None
+    effect_ac = sum(result)/len(result)
+    # if len(answer)>20:
+    #     return 0
+
+    return color_ac, effect_ac
+
+
+def layout_comparison_ac(gt, response):
+    if isinstance(response, list):
+        answer = ""
+        for item in response:
+            answer += clean_string(item)
+    if isinstance(response, str):
+        answer = clean_string(response)
+
+    if gt in answer:
+        return 1
+    else:
+        return 0
+
+def extract_numbers(s):
+
+    return [int(num) for num in re.findall(r'\d+', s)]
+
+def extract_numbers_float(s):
+
+    numbers = []
+    for num_str in re.findall(r'\d+\.\d+|\d+', s):  # 匹配小数或整数
+        if '.' in num_str:
+            numbers.append(float(num_str))
+        else:
+            numbers.append(int(num_str))
+    return numbers
+
+def extract_numbers_float2(s):
+    """提取字符串中的所有浮点数（小数），忽略整数"""
+    numbers = []
+    for num_str in re.findall(r'\d+\.\d+', s):  # 只匹配小数（必须包含小数点）
+        numbers.append(float(num_str))
+    return numbers
+def group_numbers_into_fours(num_list):
+    """
+
+    """
+    n = len(num_list)
+
+
+    result = [num_list[i:i + 4] for i in range(0, n-3, 4)]
+    return result
+
+def clean_string_for_box(input_str):
+    # 正则表达式匹配：保留方括号 []、数字、空格和逗号
+    return re.sub(r'[^\[\], .\d]', '', input_str)
+def parse_bbox_string(bbox_str):
+
+    """
+    """
+    try:
+        # 使用literal_eval将字符串解析为Python对象
+        bbox_str = clean_string_for_box(bbox_str)
+        bbox_nums = extract_numbers_float(bbox_str)
+        bboxes = group_numbers_into_fours(bbox_nums)
+        # bboxes = ast.literal_eval(bbox_str)
+        return bboxes
+    except Exception as e:
+        print("解析bbox字符串时出错:", e)
+        return []
+
+def parse_bbox_string2(bbox_str):
+
+    """
+    """
+    try:
+
+        bbox_str = clean_string_for_box(bbox_str)
+        bbox_nums = extract_numbers_float2(bbox_str)
+        bboxes = group_numbers_into_fours(bbox_nums)
+        # bboxes = ast.literal_eval(bbox_str)
+        return bboxes
+    except Exception as e:
+        print("解析bbox字符串时出错:", e)
+        return []
+
+def calculate_iou(box1, box2):
+    """
+    """
+
+
+    x1_1, y1_1, x2_1, y2_1 = box1
+    x1_2, y1_2, x2_2, y2_2 = box2
+
+    # 计算交集区域坐标
+    x_left = max(x1_1, x1_2)
+    y_top = max(y1_1, y1_2)
+    x_right = min(x2_1, x2_2)
+    y_bottom = min(y2_1, y2_2)
+
+    if x1_1 > x2_1: return 0.0
+    if y1_1 > y2_1: return 0.0
+
+    if x1_2 > x2_2: return 0.0
+    if y1_2 > y2_2: return 0.0
+
+
+    if x_right < x_left or y_bottom < y_top:
+        return 0.0
+
+
+    intersection_area = (x_right - x_left) * (y_bottom - y_top)
+
+
+    box1_area = (x2_1 - x1_1) * (y2_1 - y1_1)
+    box2_area = (x2_2 - x1_2) * (y2_2 - y1_2)
+
+
+    union_area = box1_area + box2_area - intersection_area
+
+
+    iou = intersection_area / union_area
+    return iou
+
+def calculate_centerpoint(norm_gt_bboxs, norm_pre_bbox):
+    x1_1, y1_1, x2_1, y2_1 = norm_gt_bboxs
+    x1_2, y1_2, x2_2, y2_2 = norm_pre_bbox
+
+    cx1 = (x1_1 + x2_1) / 2.0
+    cy1 = (y1_1 + y2_1) / 2.0
+
+    # 计算第二个框的中心
+    cx2 = (x1_2 + x2_2) / 2.0
+    cy2 = (y1_2 + y2_2) / 2.0
+
+    # 欧氏距离
+    dist = math.hypot(cx1 - cx2, cy1 - cy2)
+
+    return dist
+
+def calculate_area_ratio(box1, box2):
+    """
+    """
+
+
+    x1_1, y1_1, x2_1, y2_1 = box1
+    x1_2, y1_2, x2_2, y2_2 = box2
+
+    # 计算各自面积
+    box1_area = (x2_1 - x1_1) * (y2_1 - y1_1)
+    box2_area = (x2_2 - x1_2) * (y2_2 - y1_2)
+    if box1_area <= 0:
+        raise
+    if box2_area <= 0:
+        return 0.0
+
+    return box1_area/ box2_area
+
+
+
+def denorm_bbox(norm_bbox,size):
+    bbox = [0,0,0,0]
+    width,height = size
+    bbox[0] = int(norm_bbox[0] * width)
+    bbox[1] = int(norm_bbox[1] * height)
+    bbox[2] = int(norm_bbox[2] * width)
+    bbox[3] = int(norm_bbox[3] * height)
+    return bbox
+
+def norm_bbox(norm_bbox,size):
+    bbox = [0,0,0,0]
+    width,height = size
+    bbox[0] = (norm_bbox[0] / width)
+    bbox[1] = (norm_bbox[1] / height)
+    bbox[2] = (norm_bbox[2] / width)
+    bbox[3] = (norm_bbox[3] / height)
+    return bbox
+
+def bbox_number_types(bboxes):
+    """
+
+    """
+    result = []
+    for box in bboxes:
+        types = []
+        for num in box:
+            # 如果它和自身取整后相等，就当作整数
+            if isinstance(num, (int,)) or (isinstance(num, float) and num.is_integer()):
+                types.append("int")
+            else:
+                types.append("float")
+        result.append(types)
+    return result
+
+
+
+def task_4_ocr(data):
+    """  character ocr and words ocr  """
+    pure_char_ocr = []
+    colorful_char_ocr = []
+    pure_words_ocr = []
+    colorful_words_ocr = []
+    for item in data:
+        if item["task"] == "pure_char ocr":
+            gt = item["gt"]
+            response = item["response"]
+            # if word_level_ac(gt, response) < 0.1:
+            #     # print(response)
+            #     continue
+            pure_char_ocr.append(word_level_ac(gt, response))
+
+        if item["task"] == "colorful_char ocr":
+            gt = item["gt"]
+            response = item["response"]
+            # if word_level_ac(gt, response) < 0.1:
+            #     # print(response)
+            #     continue
+            colorful_char_ocr.append(word_level_ac(gt, response))
+
+        if item["task"] == "pure_words ocr":
+            gt = item["gt"]
+            response = item["response"]
+            # if word_level_ac(gt, response) < 0.1:
+            #     # print(response)
+            #     continue
+            pure_words_ocr.append(word_level_ac(gt, response))
+        if item["task"] == "colorful_words ocr":
+            gt = item["gt"]
+            response = item["response"]
+            # if word_level_ac(gt, response)<0.1:
+            #     # print(response)
+            #     continue
+            colorful_words_ocr.append(word_level_ac(gt, response))
+
+    print("pure_char_ocr      word-level accuracy: ", f"{sum(pure_char_ocr)/len(pure_char_ocr):.3f}", f" total imgs:{len(pure_char_ocr)/400}")
+    print("colorful_char_ocr  word-level accuracy: ", f"{sum(colorful_char_ocr)/len(colorful_char_ocr):.3f}", f" total imgs:{len(colorful_char_ocr)/400}")
+    print("pure_words_ocr     word-level accuracy: ", f"{sum(pure_words_ocr) / len(pure_words_ocr):.3f}", f" total imgs:{len(pure_words_ocr)/400}")
+    print("colorful_words_ocr word-level accuracy: ", f"{sum(colorful_words_ocr) / len(colorful_words_ocr):.3f}", f" total imgs:{len(colorful_words_ocr)/400}")
+
+def task_font_size(data):
+    """  font size robustness  """
+    font_size_list = [80, 75, 70, 65, 60, 55, 50, 45, 40, 35, 30, 25, 20, 15]
+    font_size_dic = {}
+    font_size_dic2 = {}
+    for size in font_size_list:
+        result1 = []
+        for item in data:
+            if item["task"] == "font size ocr":
+                if size == item["subtask"]:
+                    gt = item["gt"]
+                    response = item["response"]
+                    # if word_level_ac(gt, response)<0.1:
+                    #     continue
+
+                    result1.append(word_level_ac(gt, response))
+        font_size_dic[str(size)] = sum(result1)/len(result1)
+        font_size_dic2[str(size)] = len(result1)
+
+    # print(f"font size robustness:")
+    # for size in font_size_list:
+    #     print(f"font size {size} : {font_size_dic[str(size)]:5f}  total imgs: {font_size_dic2[str(size)]}")
+
+    font_size_dic3 = {}
+    font_size_dic4 = {}
+    for size in font_size_list:
+        result2 = []
+        for item in data:
+            if item["task"] == "font size ocr":
+                if size == item["subtask"]:
+                    gt = item["gt"]
+                    response = item["response"]
+                    if word_level_ac(gt, response)<0.1:
+                        continue
+
+                    result2.append(word_level_ac(gt, response))
+        font_size_dic3[str(size)] = sum(result2)/len(result2)
+        font_size_dic4[str(size)] = len(result2)
+
+    # print(f"font size robustness:")
+    # for size in font_size_list:
+    #     print(f"font size {size} : {font_size_dic3[str(size)]:5f}  total imgs: {font_size_dic4[str(size)]}")
+
+    values = list(font_size_dic.values())
+    mean = statistics.mean(values)
+    std = statistics.stdev(values)  # 样本标准差（ddof=1）
+
+    values3 = list(font_size_dic3.values())
+    mean3 = statistics.mean(values3)
+    std3 = statistics.stdev(values3)
+
+    recall_num = list(font_size_dic4.values())
+    mean_r = statistics.mean(recall_num)
+
+    # print(f"Mean: {mean:.3f} Std: {std:.3f} Mean: {mean3:.3f} Std: {std3:.3f} reacall_num: {mean_r}")
+    print(f"Mean: {mean:.3f} Std: {std:.3f} Mean: {mean3:.3f} Std: {std3:.3f} reacall_num: {mean_r:.3f}")
+
+def task_logo_cor(data):
+    """  logo ocr  """
+    result = []
+    for item in data:
+        if item["task"] == "logo ocr":
+            gt = item["gt"]
+            response = item["response"]
+            result.append(logo_ocr_ac(gt, response))
+    print(f"logo  ocr  accuracy: {sum(result)/len(result):.3f}  total imgs: {len(result)}")
+
+def task_poster_ocr(data):
+    """  real poster ocr  """
+    result = []
+    for item in data:
+        if item["task"] == "poster ocr":
+            if "gt" in item:
+                gt = item["gt"]
+            if "texts" in item:
+                gt = item["texts"]
+            response = item["response"]
+            ac = real_poster_ac(gt, response)
+            if ac<0.05: continue
+            result.append(ac)
+    print(f"poster ocr accuracy (entity-level): {sum(result)/len(result):.3f}  total imgs: {len(result)}")
+
+def task_font_matching_1(data):
+    """  font matching 1  """
+    result = []
+    for item in data:
+        if item["task"] == "font matching 1":
+            if "gt" in item:
+                gt = item["gt"]
+            if "texts" in item:
+                gt = item["texts"]
+            response = item["response"]
+            if refuse_option(response):
+                continue
+            # print(response)
+            result.append(font_matching_ac(gt, response))
+    print(f"font matching 1 accuracy: {sum(result) / len(result):5f}  total imgs: {len(result)}")
+    return sum(result) / len(result)
+
+def task_font_matching_2(data):
+    """  font matching 2  """
+    result = []
+    for item in data:
+        if item["task"] == "font matching 2":
+            if "gt" in item:
+                gt = item["gt"]
+            if "texts" in item:
+                gt = item["texts"]
+            response = item["response"]
+            if refuse_option(response):
+                continue
+            # print(response)
+            result.append(font_matching_ac(gt, response))
+    print(f"font matching 2 accuracy: {sum(result) / len(result):5f}  total imgs: {len(result)}")
+    return sum(result) / len(result)
+
+def task_font_matching(data):
+    """  font matching 2  """
+    result = []
+    for item in data:
+        if item["task"] == "font matching 2" or item["task"] == "font matching 1":
+            if "gt" in item:
+                gt = item["gt"]
+            if "texts" in item:
+                gt = item["texts"]
+            response = item["response"]
+            if refuse_option(response):
+                continue
+            # print(response)
+            result.append(font_matching_ac(gt, response))
+    print(f"font matching 2 accuracy: {sum(result) / len(result):.3f}  total imgs: {len(result)}")
+    return sum(result) / len(result)
+
+def task_font_attr(data):
+    """  font attributes  """
+    result = []
+    for item in data:
+        if item["task"] == "font attributes":
+            if "gt" in item:
+                gt = item["gt"]
+            if "texts" in item:
+                gt = item["texts"]
+            response = item["response"]
+            if refuse_option(response):
+                continue
+            # print(response)
+            result.append(font_attr_ac(gt, response))
+    print(f"font attributes accuracy: {sum(result) / len(result):5f}  total imgs: {len(result)}")
+
+    font_attr_list = []
+    font_attr_dic = {}
+    for item in data:
+        if item["task"] == "font attributes":
+            font_attr_list.append(item["subtask"])
+    font_attr_list = list(set(font_attr_list))
+    # print(font_attr_list)
+    for attr in font_attr_list:
+        result2 = []
+        for item in data:
+            if item["task"] == "font attributes":
+                if item["subtask"] == attr:
+                    if "gt" in item:
+                        gt = item["gt"]
+                    if "texts" in item:
+                        gt = item["texts"]
+                    response = item["response"]
+                    result2.append(font_attr_ac(gt, response))
+        font_attr_dic[attr]= sum(result2) / len(result2)
+
+    # for attr in font_attr_list:
+        # print(f"attr {attr}:  {font_attr_dic[attr]:5f}")
+    return sum(result) / len(result)
+
+def task_font_effect(data):
+    """  font effect  """
+    result = []
+    for item in data:
+        if item["task"] == "font effect":
+            if "gt" in item:
+                gt = item["gt"]
+            if "texts" in item:
+                gt = item["texts"]
+            response = item["response"]
+            # print(response)
+            result.append(font_effect_ac(gt, response))
+    print(f"font effect accuracy: {sum(result) / len(result):.5f}  total imgs: {len(result)}")
+
+    font_effect_list = []
+    font_effect_dic = {}
+    for item in data:
+        if item["task"] == "font effect":
+            font_effect_list.append(item["subtask"])
+    font_effect_list = list(set(font_effect_list))
+    # print(font_effect_list)
+
+    for effect in font_effect_list:
+        result2 = []
+        for item in data:
+            if item["task"] == "font effect":
+                if item["subtask"] == effect:
+                    if "gt" in item:
+                        gt = item["gt"]
+                    response = item["response"]
+                    result2.append(font_effect_ac(gt, response))
+        font_effect_dic[effect] = sum(result2) / len(result2)
+    # for effect in font_effect_list:
+    #     print(f"attr {effect}:  {font_effect_dic[effect]:5f}")
+
+    return sum(result) / len(result)
+
+def task_font_effect_2(data):
+    """  font effect 2 """
+    result_c = []
+    result_e = []
+    for item in data:
+        if item["task"] == "font effect 2":
+            if "gt" in item:
+                gt = item["gt"]
+            if "texts" in item:
+                gt = item["texts"]
+            response = item["response"]
+            # print(response)
+            color_ac, effect_ac = font_effect_2_ac(gt, response)
+            result_c.append(color_ac)
+            if effect_ac != None:
+                result_e.append(effect_ac)
+
+    print(f"font effect 2  color accuracy: {sum(result_c) / len(result_c):5f}  total imgs: {len(result_c)}")
+    print(f"font effect 2 effect accuracy: {sum(result_e) / len(result_e):5f}  total imgs: {len(result_e)}")
+
+    return sum(result_c) / len(result_c), sum(result_e) / len(result_e)
+
+def task_layout_comprison(data):
+    """  layout comprison  """
+    result = []
+    for item in data:
+        if item["task"] == "layout comparison":
+            if "gt" in item:
+                gt = item["gt"]
+            if "texts" in item:
+                gt = item["texts"]
+            response = item["response"]
+            # print(response)
+            result.append(font_effect_ac(gt, response))
+    print(f"layout disorder comparison accuracy: {sum(result) / len(result):5f}  total imgs: {len(result)}")
+    return sum(result) / len(result)
+
+
+def task_align_rotate(data):
+    """  layout comprison  """
+    a_result = []
+    r_result = []
+    r1_result = []
+    r2_result = []
+    r3_result = []
+
+    for item in data:
+        response = item["response"]
+        if isinstance(response, list):
+            answer = ""
+            for content in response:
+                answer += content
+        if isinstance(response, str):
+            answer = response
+
+        if item["task"] == "align and rotate":
+            if "gt" in item:
+                gt = item["gt"]
+            if "alignment" in item:
+                gt_align = item["alignment"]
+            if "rotation" in item:
+                gt_rotate = item["rotation"]
+
+            r_ac = 0
+            if "counterclockwise rotation" in gt_rotate:
+                if "counterclockwise rotation" in answer:
+                    r1_ac = 1
+                else:
+                    r1_ac = 0
+                r1_result.append(r1_ac)
+            if "no rotation" in gt_rotate:
+                if "no rotation" in answer:
+                    r2_ac = 1
+                else:
+                    r2_ac = 0
+                r2_result.append(r2_ac)
+
+            if "clockwise rotation" in gt_rotate:
+                if "counterclockwise rotation" in answer:
+                    r3_ac = 0
+                elif "clockwise rotation" in answer:
+                    r3_ac = 1
+                else:
+                    r3_ac = 0
+                r3_result.append(r3_ac)
+
+            for a in gt_align:
+                a_ac = 0
+                if a in answer:
+                    a_ac = 1
+                a_result.append(a_ac)
+
+
+    r_result.extend(r1_result)
+    r_result.extend(r2_result)
+    r_result.extend(r3_result)
+
+
+    print(f"alignment accuracy: {sum(a_result) / len(a_result):5f}  total imgs: {len(a_result)}")
+    print(f"rotation  accuracy: {sum(r1_result) / len(r1_result):5f}  total imgs: {len(r1_result)}")
+    print(f"rotation  accuracy: {sum(r2_result) / len(r2_result):5f}  total imgs: {len(r2_result)}")
+    print(f"rotation  accuracy: {sum(r3_result) / len(r3_result):5f}  total imgs: {len(r3_result)}")
+
+    return sum(a_result) / len(a_result), sum(r_result) / len(r_result)
+
+
+
+def task_poster_detection(data, max_box_num=30):
+    """  poster detection  """
+    ratio_list = []
+    wrong_recall = 0
+    iou_list = []
+    center_bias_list = []
+    area_ratio_list = []
+    for item in data:
+        if item["task"] == "poster detection":
+            if "gt" in item:
+                gt_bboxs = item["gt"]
+            if "text_bbox" in item:
+                gt_bboxs = item["text_bbox"]
+            width, height = item["size"]
+            response = item["response"]
+            if isinstance(response, list):
+                answer = ""
+                for content in response:
+                    answer += content
+            if isinstance(response, str):
+                answer = response
+
+
+            pre_bboxs = parse_bbox_string2(answer)
+            # new_item["text_bbox"] = pre_bboxs
+            # new_item["text_bbox"] = [denorm_bbox(pre_bboxs[i], [width, height]) for i in range(len(pre_bboxs))]
+            bbox_type =  bbox_number_types(pre_bboxs)
+
+            ratio = min(len(pre_bboxs) / len(gt_bboxs) , 1)
+            ratio_list.append(ratio)
+            if ratio != 1:
+                # print(f"{ratio:3f} boxes: {len(gt_bboxs)}")
+                wrong_recall += 1
+            # else:
+            """最多算5个bbox"""
+            incount_bbox_num = min(len(gt_bboxs), len(pre_bboxs), max_box_num)
+            for i in range(incount_bbox_num):
+                # print(pre_bboxs[i])
+                # if (sum(pre_bboxs[i])/len(pre_bboxs[i]))>1:
+                """calculate iou"""
+                iou1 = calculate_iou(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [width, height]))
+                # if (sum(pre_bboxs[i])/len(pre_bboxs[i]))<1:
+                iou2 = calculate_iou(norm_bbox(gt_bboxs[i], [width, height]), pre_bboxs[i])
+
+                iou3 = calculate_iou(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [1024, 1024]))
+
+                iou4 = calculate_iou(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [1000, 1000]))
+
+                ious = [iou1, iou2, iou3, iou4]
+                max_iou = max(ious)
+                max_index = ious.index(max_iou)
+
+                """calculate center distance"""
+                dis1 = calculate_centerpoint(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [width, height]))
+                # if (sum(pre_bboxs[i])/len(pre_bboxs[i]))<1:
+                dis2 = calculate_centerpoint(norm_bbox(gt_bboxs[i], [width, height]), pre_bboxs[i])
+
+                dis3 = calculate_centerpoint(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [1024, 1024]))
+
+                dis4 = calculate_centerpoint(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [1000, 1000]))
+
+                dis_list = [dis1, dis2, dis3, dis4]
+                min_center_dis = min(dis_list)
+                index = dis_list.index(min_center_dis)
+
+                """calculate area ratio"""
+                area_r_1 = calculate_area_ratio(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [width, height]))
+                # if (sum(pre_bboxs[i])/len(pre_bboxs[i]))<1:
+                area_r_2 = calculate_area_ratio(norm_bbox(gt_bboxs[i], [width, height]), pre_bboxs[i])
+
+                area_r_3 = calculate_area_ratio(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [1024, 1024]))
+
+                area_r_4 = calculate_area_ratio(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [1000, 1000]))
+
+                area_r_t = [abs(area_r_1 - 1 ), abs(area_r_2 - 1 ), abs(area_r_3 - 1 ), abs(area_r_4 - 1 )]
+                area_r_s = [area_r_1, area_r_2, area_r_3, area_r_4]
+                value = min(area_r_t)
+                index = area_r_t.index(value)
+                area_r = area_r_s[index]
+                # print("area_r",area_r)
+
+
+                iou_list.append(max_iou)
+                center_bias_list.append(min_center_dis)
+                area_ratio_list.append(area_r)
+
+    # print("wrong recall rate:", wrong_recall / len(ratio_list))
+    # print(f"ratio mean: {sum(ratio_list)/len(ratio_list)}  ration vat: {statistics.pstdev(ratio_list)} ")
+    # print("box total: ",len(iou_list))
+    # print(f"iou mean: {sum(iou_list) / len(iou_list):5f}")
+    # print(f"iou pstdev: {statistics.pstdev(iou_list):5f}")
+    #
+    # print(f"center shift mean : {sum(center_bias_list) / len(center_bias_list):5f}")
+    # print(f"center shift pstdev: {statistics.pstdev(center_bias_list):5f}")
+    #
+    # print(f"area_ratio mean: {sum(area_ratio_list) / len(area_ratio_list):5f}")
+    # print(f"area_ratio pstdev: {statistics.pstdev(area_ratio_list):5f}")
+    return sum(iou_list) / len(iou_list), sum(ratio_list)/len(ratio_list)
+
+def task_layout_generation(data):
+    """  poster detection  """
+    ratio_list = []
+    wrong_recall = 0
+    iou_list = []
+    center_bias_list = []
+    area_ratio_list = []
+    for item in data:
+        if item["task"] == "layout generation":
+            if "gt" in item:
+                gt_bboxs = item["gt"]
+            if "text_bbox" in item:
+                gt_bboxs = item["text_bbox"]
+            width, height = item["size"]
+            response = item["response"]
+            if isinstance(response, list):
+                answer = ""
+                for content in response:
+                    answer += content
+            if isinstance(response, str):
+                answer = response
+
+
+            pre_bboxs = parse_bbox_string2(answer)
+            # new_item["text_bbox"] = pre_bboxs
+            # new_item["text_bbox"] = [denorm_bbox(pre_bboxs[i], [width, height]) for i in range(len(pre_bboxs))]
+            bbox_type =  bbox_number_types(pre_bboxs)
+
+            ratio = min(len(pre_bboxs) / len(gt_bboxs), 1)
+            # ratio = len(pre_bboxs) / len(gt_bboxs)
+            ratio_list.append(ratio)
+            if ratio != 1:
+                # print(f"{ratio:3f} boxes: {len(gt_bboxs)}")
+                wrong_recall += 1
+            # else:
+            """最多算5个bbox"""
+            incount_bbox_num = min(len(gt_bboxs), len(pre_bboxs))
+            for i in range(incount_bbox_num):
+                # print(pre_bboxs[i])
+                # if (sum(pre_bboxs[i])/len(pre_bboxs[i]))>1:
+                """calculate iou"""
+                iou1 = calculate_iou(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [width, height]))
+                # if (sum(pre_bboxs[i])/len(pre_bboxs[i]))<1:
+                iou2 = calculate_iou(norm_bbox(gt_bboxs[i], [width, height]), pre_bboxs[i])
+
+                iou3 = calculate_iou(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [1024, 1024]))
+
+                iou4 = calculate_iou(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [1000, 1000]))
+
+                ious = [iou1, iou2, iou3, iou4]
+                max_iou = max(ious)
+                max_index = ious.index(max_iou)
+
+                """calculate center distance"""
+                dis1 = calculate_centerpoint(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [width, height]))
+                # if (sum(pre_bboxs[i])/len(pre_bboxs[i]))<1:
+                dis2 = calculate_centerpoint(norm_bbox(gt_bboxs[i], [width, height]), pre_bboxs[i])
+
+                dis3 = calculate_centerpoint(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [1024, 1024]))
+
+                dis4 = calculate_centerpoint(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [1000, 1000]))
+
+                dis_list = [dis1, dis2, dis3, dis4]
+                min_center_dis = min(dis_list)
+                index = dis_list.index(min_center_dis)
+
+                """calculate area ratio"""
+                area_r_1 = calculate_area_ratio(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [width, height]))
+                # if (sum(pre_bboxs[i])/len(pre_bboxs[i]))<1:
+                area_r_2 = calculate_area_ratio(norm_bbox(gt_bboxs[i], [width, height]), pre_bboxs[i])
+
+                area_r_3 = calculate_area_ratio(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [1024, 1024]))
+
+                area_r_4 = calculate_area_ratio(norm_bbox(gt_bboxs[i], [width, height]), norm_bbox(pre_bboxs[i], [1000, 1000]))
+
+                area_r_t = [abs(area_r_1 - 1 ), abs(area_r_2 - 1 ), abs(area_r_3 - 1 ), abs(area_r_4 - 1 )]
+                area_r_s = [area_r_1, area_r_2, area_r_3, area_r_4]
+                value = min(area_r_t)
+                index = area_r_t.index(value)
+                area_r = area_r_s[index]
+                if area_r >1 :
+                    area_r = 1/area_r
+                # print("area_r",area_r)
+
+
+                iou_list.append(max_iou)
+                center_bias_list.append(min_center_dis)
+                area_ratio_list.append(area_r)
+
+    # print("wrong recall rate:", wrong_recall / len(ratio_list))
+    # print(f"ratio mean: {sum(ratio_list)/len(ratio_list):.3f}  ration vat: {statistics.pstdev(ratio_list):.3f} ")
+    rate = sum(ratio_list)/len(ratio_list)
+    # print("box total: ",len(iou_list))
+    # print(f"iou mean: {sum(iou_list) / len(iou_list):.3f}")
+    # print(f"iou pstdev: {statistics.pstdev(iou_list):5f}")
+
+    # print(f"center shift mean : {sum(center_bias_list) / len(center_bias_list):.3f}")
+    bias = sum(center_bias_list) / len(center_bias_list)
+    # print(f"center shift pstdev: {statistics.pstdev(center_bias_list):.3f}")
+
+    # print(f"area_ratio mean: {sum(area_ratio_list) / len(area_ratio_list):.3f}")
+    area_rate = sum(area_ratio_list) / len(area_ratio_list)
+    # print(f"area_ratio pstdev: {statistics.pstdev(area_ratio_list):.3f}")
+
+    return bias, area_rate, rate
+
+def extract_last_bracket_list(s: str) -> list:
+    """
+    在字符串中定位最后一个 '[' 和最后一个 ']'，并将它们之间的内容提取、
+    按逗号拆分后返回为 Python 列表。
+
+    Args:
+        s (str): 输入字符串
+
+    Returns:
+        list: 拆分后的元素列表（去除两端空白），如果未找到匹配的括号，则返回空列表
+    """
+    # 查找最后一个 '[' 和最后一个 ']'
+    last_open = s.rfind('[')
+    last_close = s.rfind(']')
+
+    # 如果任意一个不存在，或顺序不对，则返回空列表
+    if last_open == -1 or last_close == -1 or last_open > last_close:
+        return []
+
+    # 提取中间的子串
+    content = s[last_open + 1:last_close]
+
+    # 按逗号分割，并去除每个元素的首尾空白
+    # 如果希望支持空元素，也可以改用 content.split(',')
+    items = [int(item.strip()) for item in content.split(',') if item.strip()]
+
+    return items
+
+def list_iou(list1, list2):
+    """
+    计算两个列表（或任何可迭代对象）中元素的交并比（IoU）。
+
+    Args:
+        list1 (list): 第一个列表
+        list2 (list): 第二个列表
+
+    Returns:
+        float: IoU 值，范围 [0, 1]。如果二者都为空，则返回 1.0。
+    """
+    set1 = set(list1)
+    set2 = set(list2)
+
+    if not set1 and not set2:
+        return 1.0  # 两个都为空，定义 IoU 为 1
+
+    intersection = set1 & set2
+    union = set1 | set2
+
+    iou = len(intersection) / len(union)
+    return iou
+
+def task_empty_space(data):
+    """  layout comprison  """
+    result = []
+    wrong_recall_list = []
+    for item in data:
+        if item["task"] == "empty space":
+            if "gt" in item:
+                gt = item["gt"]
+            response = item["response"]
+            if isinstance(response, list):
+                answer = ""
+                for content in response:
+                    answer += content
+            if isinstance(response, str):
+                answer = response
+
+            answer = extract_last_bracket_list(answer)
+            ac = list_iou(gt, answer)
+            # print(ac)
+            result.append(ac)
+            if len(gt)==len(answer):
+                wrong_recall = 1
+            else:
+                wrong_recall = 0
+            wrong_recall_list.append(wrong_recall)
+
+    # print(f"empty space accuracy: {sum(result) / len(result):.5f}  total imgs: {len(result)}")
+    # print(f"empty space recall  : {sum(wrong_recall_list) / len(wrong_recall_list):.5f}  total imgs: {len(wrong_recall_list)}")
+
+    return sum(result) / len(result) , sum(wrong_recall_list)/len(wrong_recall_list)
+
+
+def k_option_norm(rate, k):
+
+    grade = ((k*rate) - 1) / (k - 1)
+
+    return grade
+
+def refuse_option(text):
+    if isinstance(text, list):
+        response = ""
+        for item in text:
+            response += clean_string(item)
+    if isinstance(text, str):
+        response = clean_string(text)
+    gt_list = ["A","B","C","D","E","F","G","H","I"]
+    """ situation 1 No letter there"""
+    none_flag = False
+    for item in gt_list:
+        if item in response:
+            none_flag = True
+    if none_flag==False: return True
+
+    """ situation 2 """
+    if len(response)>5:
+        count = 0
+        num = 0
+        for item in gt_list:
+            count = max(response.count(item), count)
+            if response.count(item):
+                num += 1
+        if (count<=1)&(num>1):
+            return True
+
+
+def task_ads(data):
+
+    score_list = []
+    points = 0
+    for item in data:
+        if item["task"]=="advertisement reasoning":
+            item_point_list = []
+            if "judge" in item:
+                
+                for content in item["judge"]:
+                    if "Yes" in content:
+                        points += 1
+                        item_point_list.append(1)
+                    else:
+                        item_point_list.append(0)
+            score = sum(item_point_list)/len(item_point_list)
+            score_list.append(score)
+
+        # print(f"{sum(score_list)/len(score_list):.3f} {points} ")
+        print(f"{sum(score_list) / len(score_list):.3f}")
+
+
+if __name__=="__main__":
+
+    # # data = read_json_file(r"Llama-3.2-11B-Vision-Instruct_bench.json")
+    # task_4_ocr(data)
+    # task_logo_cor(data)
+    # task_poster_ocr(data)
+    # task_font_matching_1(data)
+    # task_font_matching_2(data)
+    # task_font_attr(data)
+    # task_font_effect(data)
+    # task_font_effect_2(data)
+    # task_font_size(data)
+    # task_layout_comprison(data)
+    # task_poster_detection(data)
+    # task_layout_generation(data)
+    # task_align_rotate(data)
+    # task_empty_space(data)
+    jsonlist = [
+    ]
+    for json_item in jsonlist:
+        print(os.path.basename(json_item))
+        data = read_json_file(json_item)
+        top1_iou, _ = task_poster_detection(data, max_box_num=1)
+        top3_iou, _ = task_poster_detection(data, max_box_num=3)
+        top5_iou, _ = task_poster_detection(data, max_box_num=5)
+        mean_iou, recall = task_poster_detection(data, max_box_num=30)
+        print(f"{top1_iou:.3f} & {top3_iou:.3f} & {top5_iou:.3f} & {mean_iou:.3f} & {recall:.3f}")
+
+        #
+        # bias, area_rate, rate = task_layout_generation(data)
+        # print(f"{bias:.3f} & {area_rate:.3f} & {rate:.3f}")